<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
<meta http-equiv="X-UA-Compatible" content="IE=9"/>
<title>JaDe Tokenizer: SearchEngine.cs Quellcode</title>

<link href="tabs.css" rel="stylesheet" type="text/css"/>
<link href="doxygen.css" rel="stylesheet" type="text/css" />
<link href="navtree.css" rel="stylesheet" type="text/css"/>
<script type="text/javascript" src="jquery.js"></script>
<script type="text/javascript" src="resize.js"></script>
<script type="text/javascript" src="navtree.js"></script>
<script type="text/javascript">
  $(document).ready(initResizable);
</script>
<link href="search/search.css" rel="stylesheet" type="text/css"/>
<script type="text/javascript" src="search/search.js"></script>
<script type="text/javascript">
  $(document).ready(function() { searchBox.OnSelectItem(0); });
</script>

</head>
<body>
<div id="top"><!-- do not remove this div! -->


<div id="titlearea">
<table cellspacing="0" cellpadding="0">
 <tbody>
 <tr style="height: 56px;">
  
  <td id="projectlogo"><img alt="Logo" src="JaDe.jpg"/></td>
  
  
  <td style="padding-left: 0.5em;">
   <div id="projectname">JaDe Tokenizer
   
   </div>
   
  </td>
  
  
  
 </tr>
 </tbody>
</table>
</div>

<!-- Erzeugt von Doxygen 1.7.6.1 -->
<script type="text/javascript">
var searchBox = new SearchBox("searchBox", "search",false,'Suchen');
</script>
  <div id="navrow1" class="tabs">
    <ul class="tablist">
      <li><a href="index.html"><span>Hauptseite</span></a></li>
      <li><a href="namespaces.html"><span>Pakete</span></a></li>
      <li><a href="annotated.html"><span>Klassen</span></a></li>
      <li class="current"><a href="files.html"><span>Dateien</span></a></li>
      <li>
        <div id="MSearchBox" class="MSearchBoxInactive">
        <span class="left">
          <img id="MSearchSelect" src="search/mag_sel.png"
               onmouseover="return searchBox.OnSearchSelectShow()"
               onmouseout="return searchBox.OnSearchSelectHide()"
               alt=""/>
          <input type="text" id="MSearchField" value="Suchen" accesskey="S"
               onfocus="searchBox.OnSearchFieldFocus(true)" 
               onblur="searchBox.OnSearchFieldFocus(false)" 
               onkeyup="searchBox.OnSearchFieldChange(event)"/>
          </span><span class="right">
            <a id="MSearchClose" href="javascript:searchBox.CloseResultsWindow()"><img id="MSearchCloseImg" border="0" src="search/close.png" alt=""/></a>
          </span>
        </div>
      </li>
    </ul>
  </div>
  <div id="navrow2" class="tabs2">
    <ul class="tablist">
      <li><a href="files.html"><span>Auflistung&#160;der&#160;Dateien</span></a></li>
    </ul>
  </div>
</div>
<div id="side-nav" class="ui-resizable side-nav-resizable">
  <div id="nav-tree">
    <div id="nav-tree-contents">
    </div>
  </div>
  <div id="splitbar" style="-moz-user-select:none;" 
       class="ui-resizable-handle">
  </div>
</div>
<script type="text/javascript">
  initNavTree('_search_engine_8cs.html','');
</script>
<div id="doc-content">
<div class="header">
  <div class="headertitle">
<div class="title">SearchEngine.cs</div>  </div>
</div><!--header-->
<div class="contents">
<div class="fragment"><pre class="fragment"><a name="l00001"></a>00001 ﻿using System;
<a name="l00002"></a>00002 <span class="keyword">using</span> System.Collections.Generic;
<a name="l00003"></a>00003 <span class="keyword">using</span> System.Linq;
<a name="l00004"></a>00004 <span class="keyword">using</span> System.Text;
<a name="l00005"></a>00005 <span class="keyword">using</span> System.Data;
<a name="l00006"></a>00006 <span class="keyword">using</span> System.Xml.Linq;
<a name="l00007"></a>00007 <span class="keyword">using</span> System.Windows.Forms;
<a name="l00008"></a>00008 <span class="keyword">using</span> System.IO;
<a name="l00009"></a>00009 <span class="keyword">using</span> System.Collections;
<a name="l00010"></a>00010 
<a name="l00011"></a>00011 <span class="keyword">namespace </span>JADE
<a name="l00012"></a>00012 {<span class="comment"></span>
<a name="l00013"></a>00013 <span class="comment">    /// &lt;summary&gt;</span>
<a name="l00014"></a>00014 <span class="comment">    ///*Die Klasse SearchEngine enthält die Funktionen zum Suchen eines Tokens im Wörterbuch. Mit Hilfe von Linq to XML wird wadoku.xml durchsucht, um für ein gesuchtes Token entsprechende Einträge zu finden. Dabei gibt es die Möglichkeit, nach genau übereinstimmenden Einträgen zu suchen oder aber nach allen Einträgen, die wie das Token beginnen. So können eventuelle falsche Zerlegungen des TinySegmenters mit Hilfe von Wadoku und der Bearbeiten-Funktion verbessert werden.</span>
<a name="l00015"></a>00015 <span class="comment">    ///*&lt;para&gt;Benutzt wurde eine XML-Dump des frei verfügbaren Wörterbuch-Projektes Wadoku&lt;/para&gt;</span>
<a name="l00016"></a>00016 <span class="comment">    ///*&lt;para&gt;&lt;a href=&quot;http://www.wadoku.de/wiki/x/ZQE&quot;&gt;http://www.wadoku.de/wiki/x/ZQE&lt;/a&gt;&lt;/para&gt;</span>
<a name="l00017"></a>00017 <span class="comment">    /// &lt;/summary&gt;</span>
<a name="l00018"></a><a class="code" href="class_j_a_d_e_1_1_search_engine.html">00018</a> <span class="comment"></span>    <span class="keyword">public</span> <span class="keyword">class </span><a class="code" href="class_j_a_d_e_1_1_search_engine.html" title="Die Klasse SearchEngine enthält die Funktionen zum Suchen eines Tokens im Wörterbuch. Mit Hilfe von Linq to XML wird wadoku.xml durchsucht, um für ein gesuchtes Token entsprechende Einträge zu finden. Dabei gibt es die Möglichkeit, nach genau übereinstimmenden Einträgen zu suchen oder aber nach allen Einträgen, die wie das Token beginnen. So können eventuelle falsche Zerlegungen des TinySegmenters mit Hilfe von Wadoku und der Bearbeiten-Funktion verbessert werden.">SearchEngine</a>
<a name="l00019"></a>00019     {<span class="comment"></span>
<a name="l00020"></a>00020 <span class="comment">        /**Diese Variable dient der Klasse SearchEngine als Referenz auf ein DataSet, das die einzelnen Suchergebnisse, die bereits angefordert wurden, speichert. */</span>
<a name="l00021"></a><a class="code" href="class_j_a_d_e_1_1_search_engine.html#a3ca0213ee6de4759d65608a96ae13c69">00021</a>         <span class="keyword">private</span> <span class="keyword">static</span> System.Data.DataSet <a class="code" href="class_j_a_d_e_1_1_search_engine.html#a3ca0213ee6de4759d65608a96ae13c69">dataSet</a>;<span class="comment"></span>
<a name="l00022"></a>00022 <span class="comment">        /// @cond</span>
<a name="l00023"></a>00023 <span class="comment"></span>        <span class="keyword">private</span> <span class="keyword">static</span> <a class="code" href="class_j_a_d_e_1_1_search_engine.html" title="Die Klasse SearchEngine enthält die Funktionen zum Suchen eines Tokens im Wörterbuch. Mit Hilfe von Linq to XML wird wadoku.xml durchsucht, um für ein gesuchtes Token entsprechende Einträge zu finden. Dabei gibt es die Möglichkeit, nach genau übereinstimmenden Einträgen zu suchen oder aber nach allen Einträgen, die wie das Token beginnen. So können eventuelle falsche Zerlegungen des TinySegmenters mit Hilfe von Wadoku und der Bearbeiten-Funktion verbessert werden.">SearchEngine</a> engine; <span class="comment">//Platzhalter, der zur Umsetzung des Singleton-Entwurfsmusters dient.</span>
<a name="l00024"></a>00024         <span class="keyword">private</span> <span class="keyword">static</span> XNamespace xns; <span class="comment">//Namespace-Angabe für Linq to XML wird hier gespeichert.</span>
<a name="l00025"></a>00025         <span class="keyword">private</span> <span class="keyword">static</span> XDocument wadoku; <span class="comment">//Variable für die Referenz auf das Wörterbuch.</span>
<a name="l00026"></a>00026         <span class="keyword">private</span> <span class="keyword">static</span> Hashtable posDeciphering; <span class="comment">// Hier wird beim Initialisieren eine Referenz auf eine Hashtable gespeichert, die bei der Erstellung von Einträgen für das Suchergebnis POS-Tag-Abkürzungen im Wörterbuch leserlich darstellbar macht. </span><span class="comment"></span>
<a name="l00027"></a>00027 <span class="comment">        /// @endcond</span>
<a name="l00028"></a>00028 <span class="comment"></span><span class="comment">        /**</span>
<a name="l00029"></a>00029 <span class="comment">         * Private Konstruktor für die Klasse SearchEngine.</span>
<a name="l00030"></a>00030 <span class="comment">         */</span> 
<a name="l00031"></a><a class="code" href="class_j_a_d_e_1_1_search_engine.html#a0a641dc68b5d3d8b15cb3291090dc264">00031</a>         <span class="keyword">private</span> <a class="code" href="class_j_a_d_e_1_1_search_engine.html#a0a641dc68b5d3d8b15cb3291090dc264">SearchEngine</a>()
<a name="l00032"></a>00032         {
<a name="l00033"></a>00033             <span class="keywordflow">if</span> (engine != null) <span class="comment">//Falls bereits eine Instanz dieser Klasse erzeugt worden ist, ... =&gt; siehe Exception-Nachricht</span>
<a name="l00034"></a>00034             {
<a name="l00035"></a>00035                 <span class="keywordflow">throw</span> <span class="keyword">new</span> InvalidOperationException(<span class="stringliteral">&quot;Es ist unmöglich eine weitere Instanz der Singleton-Klasse SearchEngine zu erzeugen.&quot;</span>);
<a name="l00036"></a>00036             }
<a name="l00037"></a>00037             <span class="keywordflow">if</span> (!File.Exists(<span class="stringliteral">&quot;wadoku.xml&quot;</span>)) <span class="comment">//Dient dazu, Probleme beim Lesezugriff auf das Wörterbuch abzufangen. =&gt; siehe Exception-Nachricht</span>
<a name="l00038"></a>00038             {
<a name="l00039"></a>00039                 <span class="keywordflow">throw</span> <span class="keyword">new</span> ArgumentException(<span class="stringliteral">&quot;Die Wörterbuchdatei konnte nicht gefunden werden.&quot;</span>);
<a name="l00040"></a>00040             }
<a name="l00041"></a>00041 
<a name="l00042"></a>00042             <a class="code" href="class_j_a_d_e_1_1_search_engine.html#a3ca0213ee6de4759d65608a96ae13c69">dataSet</a> = <span class="keyword">new</span> DataSet(); <span class="comment">//Initialisiere das benötigte DataSet dataSet.</span>
<a name="l00043"></a>00043             xns = <span class="stringliteral">&quot;http://www.wadoku.de/xml/entry&quot;</span>; <span class="comment">//Angabe des Namespaces für wadoku.xml</span>
<a name="l00044"></a>00044             wadoku = XDocument.Load(<span class="stringliteral">&quot;wadoku.xml&quot;</span>); <span class="comment">//Relativer Pfad zu wadoku.xml wird hier angegeben</span>
<a name="l00045"></a>00045 
<a name="l00046"></a>00046             posDeciphering = <span class="keyword">new</span> Hashtable() <span class="comment">//Hashtable, die bei der Erstellung von Einträgen für das Suchergebnis POS-Tag-Abkürzungen im Wörterbuch leserlich darstellbar macht</span>
<a name="l00047"></a>00047             {
<a name="l00048"></a>00048                     {<span class="stringliteral">&quot;N&quot;</span>, <span class="stringliteral">&quot;Nomen&quot;</span>},
<a name="l00049"></a>00049                     {<span class="stringliteral">&quot;V&quot;</span>, <span class="stringliteral">&quot;Verb&quot;</span>},
<a name="l00050"></a>00050                     {<span class="stringliteral">&quot;Adj&quot;</span>, <span class="stringliteral">&quot;Adjektiv&quot;</span>},
<a name="l00051"></a>00051                     {<span class="stringliteral">&quot;Adn&quot;</span>, <span class="stringliteral">&quot;Adnomen&quot;</span>},
<a name="l00052"></a>00052                     {<span class="stringliteral">&quot;Adv&quot;</span>, <span class="stringliteral">&quot;Adverb&quot;</span>},
<a name="l00053"></a>00053                     {<span class="stringliteral">&quot;BspSatz&quot;</span>, <span class="stringliteral">&quot;Beispielsatz&quot;</span>},
<a name="l00054"></a>00054                     {<span class="stringliteral">&quot;Hilfsv&quot;</span>, <span class="stringliteral">&quot;Hilfsverb&quot;</span>},
<a name="l00055"></a>00055                     {<span class="stringliteral">&quot;Interj&quot;</span>, <span class="stringliteral">&quot;Interjektion&quot;</span>},
<a name="l00056"></a>00056                     {<span class="stringliteral">&quot;Kanji&quot;</span>, <span class="stringliteral">&quot;Einzel-Kanji&quot;</span>},
<a name="l00057"></a>00057                     {<span class="stringliteral">&quot;Konj&quot;</span>, <span class="stringliteral">&quot;Konjunktion&quot;</span>},
<a name="l00058"></a>00058                     {<span class="stringliteral">&quot;Part&quot;</span>, <span class="stringliteral">&quot;Partikel&quot;</span>},
<a name="l00059"></a>00059                     {<span class="stringliteral">&quot;Praef&quot;</span>, <span class="stringliteral">&quot;Präfix&quot;</span>},
<a name="l00060"></a>00060                     {<span class="stringliteral">&quot;Pron&quot;</span>, <span class="stringliteral">&quot;Pronomen&quot;</span>},
<a name="l00061"></a>00061                     {<span class="stringliteral">&quot;Suff&quot;</span>, <span class="stringliteral">&quot;Suffix&quot;</span>},
<a name="l00062"></a>00062                     {<span class="stringliteral">&quot;Zus&quot;</span>, <span class="stringliteral">&quot;Zusammensetzung&quot;</span>},
<a name="l00063"></a>00063                     {<span class="stringliteral">&quot;Redensart&quot;</span>, <span class="stringliteral">&quot;Redensart&quot;</span>},
<a name="l00064"></a>00064                     {<span class="stringliteral">&quot;Wortkomp&quot;</span>, <span class="stringliteral">&quot;Wortkomposition&quot;</span>},
<a name="l00065"></a>00065                     {<span class="stringliteral">&quot;Sonderzeichen&quot;</span>, <span class="stringliteral">&quot;Sonderzeichen&quot;</span>},
<a name="l00066"></a>00066                     {<span class="stringliteral">&quot;Themenpart&quot;</span>, <span class="stringliteral">&quot;Themenpartikel&quot;</span>},
<a name="l00067"></a>00067                     {<span class="stringliteral">&quot;Sonderform&quot;</span>, <span class="stringliteral">&quot;Sonderform&quot;</span>},
<a name="l00068"></a>00068                     {<span class="stringliteral">&quot;Undef&quot;</span>, <span class="stringliteral">&quot;Undefiniert&quot;</span>}
<a name="l00069"></a>00069             };
<a name="l00070"></a>00070         }<span class="comment"></span>
<a name="l00071"></a>00071 <span class="comment">        /**</span>
<a name="l00072"></a>00072 <span class="comment">         * Get-Funktion, die das Singelton-Entwurfsmuster für die Klasse SearchEngine umsetzt. Dadurch wird gewährleistet, dass nur eine und immer dieselbe Instanz der SearchEngine-Klasse verwendet wird.</span>
<a name="l00073"></a>00073 <span class="comment">         * Überprüft, ob es schon eine Instanz der Klasse SearchEngine gibt und erstellt, falls nicht, eine solche.</span>
<a name="l00074"></a>00074 <span class="comment">        */</span> 
<a name="l00075"></a>00075         <span class="keyword">public</span> <span class="keyword">static</span> <a class="code" href="class_j_a_d_e_1_1_search_engine.html" title="Die Klasse SearchEngine enthält die Funktionen zum Suchen eines Tokens im Wörterbuch. Mit Hilfe von Linq to XML wird wadoku.xml durchsucht, um für ein gesuchtes Token entsprechende Einträge zu finden. Dabei gibt es die Möglichkeit, nach genau übereinstimmenden Einträgen zu suchen oder aber nach allen Einträgen, die wie das Token beginnen. So können eventuelle falsche Zerlegungen des TinySegmenters mit Hilfe von Wadoku und der Bearbeiten-Funktion verbessert werden.">SearchEngine</a> <a class="code" href="class_j_a_d_e_1_1_search_engine.html#aadb00d679378ffa10abfd5b55c507581">Engine</a>
<a name="l00076"></a><a class="code" href="class_j_a_d_e_1_1_search_engine.html#aadb00d679378ffa10abfd5b55c507581">00076</a>         {
<a name="l00077"></a>00077             <span class="keyword">get</span>
<a name="l00078"></a>00078             {
<a name="l00079"></a>00079                 <span class="keywordflow">if</span> (engine == null)
<a name="l00080"></a>00080                 {
<a name="l00081"></a>00081                     engine = <span class="keyword">new</span> <a class="code" href="class_j_a_d_e_1_1_search_engine.html#a0a641dc68b5d3d8b15cb3291090dc264">SearchEngine</a>();
<a name="l00082"></a>00082                 }
<a name="l00083"></a>00083                 <span class="keywordflow">return</span> engine;
<a name="l00084"></a>00084             }
<a name="l00085"></a>00085         }
<a name="l00086"></a>00086 
<a name="l00087"></a>00087 <span class="comment"></span>
<a name="l00088"></a>00088 <span class="comment">        /**</span>
<a name="l00089"></a>00089 <span class="comment">        * Funktion zum Leeren der DataTable, in der sich die Suchergebnisse befinden.</span>
<a name="l00090"></a>00090 <span class="comment">        */</span> 
<a name="l00091"></a><a class="code" href="class_j_a_d_e_1_1_search_engine.html#a68917c191a39da5d6fabe0f74c828914">00091</a>         <span class="keyword">public</span> <span class="keywordtype">void</span> <a class="code" href="class_j_a_d_e_1_1_search_engine.html#a68917c191a39da5d6fabe0f74c828914">clearDataSet</a>()
<a name="l00092"></a>00092         {
<a name="l00093"></a>00093             <span class="keywordflow">while</span> (<a class="code" href="class_j_a_d_e_1_1_search_engine.html#a3ca0213ee6de4759d65608a96ae13c69">dataSet</a>.Tables.Count &gt; 0) <span class="comment">// Solange noch Tabellen in dataSet gespeichert sind ...</span>
<a name="l00094"></a>00094             {
<a name="l00095"></a>00095                 DataTable table = <a class="code" href="class_j_a_d_e_1_1_search_engine.html#a3ca0213ee6de4759d65608a96ae13c69">dataSet</a>.Tables[0]; <span class="comment">// ... betrachte die die Tabelle mit Indexwert 0 und ...</span>
<a name="l00096"></a>00096                 <span class="keywordflow">if</span> (<a class="code" href="class_j_a_d_e_1_1_search_engine.html#a3ca0213ee6de4759d65608a96ae13c69">dataSet</a>.Tables.CanRemove(table)) <a class="code" href="class_j_a_d_e_1_1_search_engine.html#a3ca0213ee6de4759d65608a96ae13c69">dataSet</a>.Tables.Remove(table); <span class="comment">// ... falls die Tabelle entfernt werden kann, entferne sie auch.</span>
<a name="l00097"></a>00097             }
<a name="l00098"></a>00098         }
<a name="l00099"></a>00099 <span class="comment"></span>
<a name="l00100"></a>00100 <span class="comment">        /**</span>
<a name="l00101"></a>00101 <span class="comment">         * Funktion zum Löschen einer Table aus dem Dataset. Dies kann notwendig sein, wenn ein Token geändert wurde. Der bereits bestehende (alte) Eintrag muss nun aus der Datatable gelöscht werden.</span>
<a name="l00102"></a>00102 <span class="comment">         * Damit bei einer erneuten Suchanfrage nicht das alte Table-Objekt aufgerufen wird, sondern eine neue Suche initiiert wird.</span>
<a name="l00103"></a>00103 <span class="comment">         * @param[in] satzNr Int-Wert des Satzes in dem sich der Token befindet dessen Table-Objekt in dem Dataset gelöscht werden soll.</span>
<a name="l00104"></a>00104 <span class="comment">         * @param[in] tokenNr Int-Wert des Tokens dessen Table-Objekt in dem Dataset gelöscht werden soll.</span>
<a name="l00105"></a>00105 <span class="comment">        */</span>
<a name="l00106"></a><a class="code" href="class_j_a_d_e_1_1_search_engine.html#afd36b5e9cd5a78e215e11a5083cdb015">00106</a>         <span class="keyword">public</span> <span class="keyword">static</span> <span class="keywordtype">void</span> <a class="code" href="class_j_a_d_e_1_1_search_engine.html#afd36b5e9cd5a78e215e11a5083cdb015">DisposeTable</a>(<span class="keywordtype">int</span> satzNr, <span class="keywordtype">int</span> tokenNr)
<a name="l00107"></a>00107         {
<a name="l00108"></a>00108             <span class="comment">//Die Variablen speichern (u.U. auch null-Referenz) Referenzen auf evtl. vorhandenen Tabellen mit Suchergebnissen (jeweils für genaue Übereinstimmung und </span>
<a name="l00109"></a>00109             <span class="comment">//für Einträge, die wie das Token beginnen) für das durch die Parameter eindeutig bestimmtes Token.</span>
<a name="l00110"></a>00110             DataTable tableToDispose = <a class="code" href="class_j_a_d_e_1_1_search_engine.html#a3ca0213ee6de4759d65608a96ae13c69">dataSet</a>.Tables[<span class="stringliteral">&quot;results_&quot;</span> + satzNr + tokenNr];
<a name="l00111"></a>00111             DataTable tableToDispose_absolute = <a class="code" href="class_j_a_d_e_1_1_search_engine.html#a3ca0213ee6de4759d65608a96ae13c69">dataSet</a>.Tables[<span class="stringliteral">&quot;results_&quot;</span> + satzNr + tokenNr + <span class="stringliteral">&quot;_absolute&quot;</span>];
<a name="l00112"></a>00112 
<a name="l00113"></a>00113             <span class="comment">//Falls die Tabellen gefunden werden (keine null-Referenz) und sie gelöscht werden können, werden sie entfernt.</span>
<a name="l00114"></a>00114             <span class="keywordflow">if</span> (<a class="code" href="class_j_a_d_e_1_1_search_engine.html#a3ca0213ee6de4759d65608a96ae13c69">dataSet</a>.Tables.CanRemove(tableToDispose)) <a class="code" href="class_j_a_d_e_1_1_search_engine.html#a3ca0213ee6de4759d65608a96ae13c69">dataSet</a>.Tables.Remove(tableToDispose);
<a name="l00115"></a>00115             <span class="keywordflow">if</span> (<a class="code" href="class_j_a_d_e_1_1_search_engine.html#a3ca0213ee6de4759d65608a96ae13c69">dataSet</a>.Tables.CanRemove(tableToDispose_absolute)) <a class="code" href="class_j_a_d_e_1_1_search_engine.html#a3ca0213ee6de4759d65608a96ae13c69">dataSet</a>.Tables.Remove(tableToDispose_absolute);
<a name="l00116"></a>00116         }
<a name="l00117"></a>00117 <span class="comment"></span>
<a name="l00118"></a>00118 <span class="comment">         /**</span>
<a name="l00119"></a>00119 <span class="comment">          * Funktion zum Ändern der Indizes im Namen einer Table aus dem Dataset. Gemäß dem Wert von left soll eine Verschiebung der Indizes im Tabellennamen nach links bzw. nach rechts erfolgen.</span>
<a name="l00120"></a>00120 <span class="comment">          * Dies kann notwendig sein, wenn ein Token geändert wurde. Andere bereits getätigte Suchergebnistabellen werden dann nicht mehr gefunden. </span>
<a name="l00121"></a>00121 <span class="comment">          * Diese Funktion kann bei einer geplanten, verbesserten Datenstruktur vernachlässigt werden. </span>
<a name="l00122"></a>00122 <span class="comment">          * @param[in] satzNr Int-Wert des Satzes, in dem sich das Token befindet, dessen Table-Objekt im Dataset angepasst werden soll.</span>
<a name="l00123"></a>00123 <span class="comment">          * @param[in] tokenNr Int-Wert des Tokens, dessen Table-Objekt im Dataset angepasst werden soll.</span>
<a name="l00124"></a>00124 <span class="comment">          * @param[in] left bool-Wert, der die Richtung der Verschiebung bestimmt.</span>
<a name="l00125"></a>00125 <span class="comment">          */</span>
<a name="l00126"></a><a class="code" href="class_j_a_d_e_1_1_search_engine.html#a41708a7451c96c92fa1dcab5dad831a7">00126</a>         <span class="keyword">public</span> <span class="keyword">static</span> <span class="keywordtype">void</span> <a class="code" href="class_j_a_d_e_1_1_search_engine.html#a41708a7451c96c92fa1dcab5dad831a7">ShiftTable</a>(<span class="keywordtype">int</span> satzNr, <span class="keywordtype">int</span> tokenNr, <span class="keywordtype">bool</span> left)
<a name="l00127"></a>00127         {
<a name="l00128"></a>00128             <span class="comment">//alten Tabellennamen speichern</span>
<a name="l00129"></a>00129             <span class="keywordtype">string</span> oldTablename = <span class="stringliteral">&quot;results_&quot;</span> + satzNr + tokenNr;
<a name="l00130"></a>00130 
<a name="l00131"></a>00131             <span class="comment">//Gemäß dem Wert von left soll eine Verschiebung der Indizes im Tabellennamen  nach links bzw. nach rechts erfolgen. Die Änderung am Tabellennamen wird hier entsprechend vorbereitet.</span>
<a name="l00132"></a>00132             <span class="keywordtype">string</span> newTablename = <span class="stringliteral">&quot;results_&quot;</span> + satzNr + ((left) ? (tokenNr - 1) : (tokenNr + 1));
<a name="l00133"></a>00133 
<a name="l00134"></a>00134             <span class="comment">//Falls die Tabellen gefunden werden, werden die im Namen auftauchenden Token-Indizes gemäß dem Wert von left nach links oder nach rechts verschoben.</span>
<a name="l00135"></a>00135             <span class="keywordflow">if</span> (<a class="code" href="class_j_a_d_e_1_1_search_engine.html#a3ca0213ee6de4759d65608a96ae13c69">dataSet</a>.Tables.Contains(oldTablename)) <a class="code" href="class_j_a_d_e_1_1_search_engine.html#a3ca0213ee6de4759d65608a96ae13c69">dataSet</a>.Tables[oldTablename].TableName = newTablename;
<a name="l00136"></a>00136             if (<a class="code" href="class_j_a_d_e_1_1_search_engine.html#a3ca0213ee6de4759d65608a96ae13c69">dataSet</a>.Tables.Contains(oldTablename + <span class="stringliteral">&quot;_absolute&quot;</span>)) <a class="code" href="class_j_a_d_e_1_1_search_engine.html#a3ca0213ee6de4759d65608a96ae13c69">dataSet</a>.Tables[oldTablename + <span class="stringliteral">&quot;_absolute&quot;</span>].TableName = newTablename + <span class="stringliteral">&quot;_absolute&quot;</span>;
<a name="l00137"></a>00137         }
<a name="l00138"></a>00138 <span class="comment"></span>
<a name="l00139"></a>00139 <span class="comment">        /**</span>
<a name="l00140"></a>00140 <span class="comment">         * Diese Suchfunktion erhält Informationen über das gesuchte Token, sucht danach in wadoku.xml und liefert eine DataTable mit Ergebnissen zurück. </span>
<a name="l00141"></a>00141 <span class="comment">         * @param[in] satzNr int-Wert des Satzes in dem sich das Token befindet, das im Wörterbuch gesucht werden soll.</span>
<a name="l00142"></a>00142 <span class="comment">         * @param[in] tokenNr int-Wert des Tokens der im Wörterbuch gesucht werden soll.</span>
<a name="l00143"></a>00143 <span class="comment">         * @param[in] token String-Repräsentation des gesuchten Tokens.</span>
<a name="l00144"></a>00144 <span class="comment">         * @param[in] absolute bool-Wert der angibt, ob nach genauer Übereinstimmung oder extensiv gesucht werden soll.</span>
<a name="l00145"></a>00145 <span class="comment">         * @param[out] outputTable DataTable-Objekt mit den gefundenen Suchergebnissen.</span>
<a name="l00146"></a>00146 <span class="comment">        */</span>
<a name="l00147"></a><a class="code" href="class_j_a_d_e_1_1_search_engine.html#ae6d263b232b5cba97948b0df7f66c146">00147</a>         <span class="keyword">public</span> DataTable <a class="code" href="class_j_a_d_e_1_1_search_engine.html#ae6d263b232b5cba97948b0df7f66c146">search</a>(<span class="keywordtype">string</span> token, <span class="keywordtype">int</span> satzNr, <span class="keywordtype">int</span> tokenNr, <span class="keywordtype">bool</span> absolute)
<a name="l00148"></a>00148         {
<a name="l00149"></a>00149             <span class="comment">//Wenn im dataSet schoneinmal dasselbe Token mit/ohne genauer Übereinstimmung gesucht wurde, ...</span>
<a name="l00150"></a>00150             <span class="keywordflow">if</span> (<a class="code" href="class_j_a_d_e_1_1_search_engine.html#a3ca0213ee6de4759d65608a96ae13c69">dataSet</a>.Tables.Contains(<span class="stringliteral">&quot;results_&quot;</span> + satzNr + tokenNr + ((absolute) ? <span class="stringliteral">&quot;_absolute&quot;</span> : <span class="stringliteral">&quot;&quot;</span>)))
<a name="l00151"></a>00151             {
<a name="l00152"></a>00152                 <span class="comment">//gib die entsprechende Tabelle zurück.</span>
<a name="l00153"></a>00153                 <span class="keywordflow">return</span> <a class="code" href="class_j_a_d_e_1_1_search_engine.html#a3ca0213ee6de4759d65608a96ae13c69">dataSet</a>.Tables[<span class="stringliteral">&quot;results_&quot;</span> + satzNr + tokenNr + ((absolute) ? <span class="stringliteral">&quot;_absolute&quot;</span> : <span class="stringliteral">&quot;&quot;</span>)];
<a name="l00154"></a>00154             }
<a name="l00155"></a>00155             <span class="comment">//Falls noch nicht nach dem Token gesucht wurde, führe eine Suche in Wadoku aus.</span>
<a name="l00156"></a>00156             <span class="keywordflow">else</span>
<a name="l00157"></a>00157             {
<a name="l00158"></a>00158                 <span class="comment">//Erzeuge einen Knoten, der alle Suchergebnisknoten enthält,</span>
<a name="l00159"></a>00159                 XElement results = <span class="keyword">new</span> XElement(<span class="stringliteral">&quot;results&quot;</span>,
<a name="l00160"></a>00160                                 <span class="comment">//Durchsuche alle Knoten, die der Wurzelknoten in wadoku.xml enthält, ...</span>
<a name="l00161"></a>00161                                 (from entry in wadoku.Root.Elements().OfType&lt;XElement&gt;()
<a name="l00162"></a>00162                                  <span class="comment">//lasse validateEntry den &lt;form&gt;-Knoten auf die durch absolute bestimmte Weise nach dem String token durchsuchen </span>
<a name="l00163"></a>00163                                  where <a class="code" href="class_j_a_d_e_1_1_search_engine.html#abbd8a3eed5abc30b00c57f8c28326a78">validateEntry</a>(entry.Element(xns + <span class="stringliteral">&quot;form&quot;</span>), token, absolute)
<a name="l00164"></a>00164                                  <span class="comment">//und wähle für einen neu erstellten &lt;result&gt;-Knoten die folgenden Elemente aus dem Wadoku-Eintrag aus:</span>
<a name="l00165"></a>00165                                  select <span class="keyword">new</span> XElement(<span class="stringliteral">&quot;result&quot;</span>, <span class="keyword">new</span> XElement(<span class="stringliteral">&quot;orths&quot;</span>, entry.Element(xns + <span class="stringliteral">&quot;form&quot;</span>).Elements(xns + <span class="stringliteral">&quot;orth&quot;</span>)),   <span class="comment">//neues xml-Element, das aus dem &lt;form&gt;-Knoten alle japanischen Schreibweisen aufnimmt</span>
<a name="l00166"></a>00166                                                                entry.Element(xns + <span class="stringliteral">&quot;gramGrp&quot;</span>),                                              <span class="comment">//xml-Element mit grammatischen (u.a. POS-Infos) Informationen </span>
<a name="l00167"></a>00167                                                                <span class="keyword">new</span> XElement(<span class="stringliteral">&quot;prons&quot;</span>, entry.Element(xns + <span class="stringliteral">&quot;form&quot;</span>).Elements(xns + <span class="stringliteral">&quot;pron&quot;</span>)),   <span class="comment">//neues xml-Element, das aus dem &lt;form&gt;-Knoten alle japanischen Umschriften aufnimmt</span>
<a name="l00168"></a>00168                                                                <span class="keyword">new</span> XElement(<span class="stringliteral">&quot;senses&quot;</span>, entry.Elements(xns + <span class="stringliteral">&quot;sense&quot;</span>)))));                    <span class="comment">//neues xml-Element, das aus dem Eintrag alle &lt;sense&gt;-Knoten mit deutschen Bedeutungen aufnimmt      </span>
<a name="l00169"></a>00169                 <span class="comment">//Wurden &lt;result&gt;-Knoten für gefundene Einträge erstellt, ...</span>
<a name="l00170"></a>00170                 DataTable outputTable = (results.HasElements) ?
<a name="l00171"></a>00171                                             <span class="comment">//So erstelle eine DataTable mit entsprechend formatierten Ergenissen. Erstelle ansonsten eine leere DataTable.</span>
<a name="l00172"></a>00172                                             (<a class="code" href="class_j_a_d_e_1_1_search_engine.html#a5afb43c7724a532b30eb7d305ab67235">createResultTable</a>(results, satzNr, tokenNr, absolute)) : (<span class="keyword">new</span> DataTable());
<a name="l00173"></a>00173                 <span class="comment">//Gib die der Variable outputTable zugewiesene Tabelle zurück.</span>
<a name="l00174"></a>00174                 <span class="keywordflow">return</span> outputTable;
<a name="l00175"></a>00175             }
<a name="l00176"></a>00176 
<a name="l00177"></a>00177         }
<a name="l00178"></a>00178 <span class="comment"></span>
<a name="l00179"></a>00179 <span class="comment">        /**</span>
<a name="l00180"></a>00180 <span class="comment">         * Die Funktion durchsucht einen Wadokueintrag nach japanischen Zeichenketten, die je nach Ausprägung von absolute genau mit token übereinstimmen oder mit token beginnen.</span>
<a name="l00181"></a>00181 <span class="comment">         * @param[in] form XElement-Objekt, welches das Form-Element eines Wadoku-Eintrages beinhaltet.</span>
<a name="l00182"></a>00182 <span class="comment">         * @param[in] token String-Repräsentation des gesuchten Token.</span>
<a name="l00183"></a>00183 <span class="comment">         * @param[in] absolute bool-Wert, der angibt ob nach genauer Übereinstimmung oder Extensiv gesucht wird.</span>
<a name="l00184"></a>00184 <span class="comment">         * @param[out] entryIsValid bool-Wert der angibt, ob Übereinstimmung vorliegt oder nicht.</span>
<a name="l00185"></a>00185 <span class="comment">        */</span>
<a name="l00186"></a><a class="code" href="class_j_a_d_e_1_1_search_engine.html#abbd8a3eed5abc30b00c57f8c28326a78">00186</a>         <span class="keyword">private</span> <span class="keywordtype">bool</span> <a class="code" href="class_j_a_d_e_1_1_search_engine.html#abbd8a3eed5abc30b00c57f8c28326a78">validateEntry</a>(XElement form, <span class="keywordtype">string</span> token, <span class="keywordtype">bool</span> absolute)
<a name="l00187"></a>00187         {
<a name="l00188"></a>00188             <span class="keywordtype">bool</span> entryIsValid = <span class="keyword">false</span>; <span class="comment">//Nimm an, dass der Eintrag nicht passend ist.</span>
<a name="l00189"></a>00189             <span class="keywordtype">bool</span> currentFormDescendantIsValid = <span class="keyword">false</span>; <span class="comment">//Nimm an, dass der gerade in der Schleife betrachtete Knoten innerhalb des &lt;form&gt;-Knotens nicht passend ist.</span>
<a name="l00190"></a>00190 
<a name="l00191"></a>00191             <span class="keywordflow">foreach</span> (XElement formEntry <span class="keywordflow">in</span> form.Elements())<span class="comment">//Durchlaufe alle Elemente im &lt;form&gt;-Knoten.</span>
<a name="l00192"></a>00192             {
<a name="l00193"></a>00193                 <span class="comment">//Falls der &lt;text&gt;-Knoten im gerade betrachteten Element denselben String wie token enthält oder ... </span>
<a name="l00194"></a>00194                 <span class="keywordflow">if</span> ((absolute &amp;&amp; (currentFormDescendantIsValid = formEntry.Element(xns + <span class="stringliteral">&quot;text&quot;</span>).Value == token)) ||
<a name="l00195"></a>00195                     <span class="comment">// ... falls der &lt;text&gt;-Knoten im gerade betrachteten Element einen String enthält, der mit dem String token beginnt ... </span>
<a name="l00196"></a>00196                     (!absolute &amp;&amp; (currentFormDescendantIsValid = formEntry.Element(xns + <span class="stringliteral">&quot;text&quot;</span>).Value.StartsWith(token)))) 
<a name="l00197"></a>00197                     <span class="comment">// ... so wird currentFormDescendantIsValid auf true gesetzt ...</span>
<a name="l00198"></a>00198                 {
<a name="l00199"></a>00199                     <span class="comment">// ... und auch entryIsValid wird auf true gesetzt.</span>
<a name="l00200"></a>00200                     entryIsValid = currentFormDescendantIsValid;
<a name="l00201"></a>00201                 }
<a name="l00202"></a>00202                 <span class="comment">//Ansonsten wird currentFormDescendantIsValid auf false gesetzt und entryIsValid wird nicht verändert (bleibt also ggf. true).</span>
<a name="l00203"></a>00203             }
<a name="l00204"></a>00204             <span class="keywordflow">return</span> entryIsValid; <span class="comment">//Der Wert von entryIsValid wird nun zurückgegeben.</span>
<a name="l00205"></a>00205         }
<a name="l00206"></a>00206 <span class="comment"></span>
<a name="l00207"></a>00207 <span class="comment">        /**</span>
<a name="l00208"></a>00208 <span class="comment">         * Diese Funktion wird von search dazu verwendet, eine DataTable für die Anzeige zu erstellen. Mit Hilfe von defineResultTable wird dem dataSet eine Tabelle hinzugefügt und innerhalb der Funktion createResultTable selbst wird die Tabelle mit formatierten Daten aus der Wadoku-XML-Datei gefüllt.</span>
<a name="l00209"></a>00209 <span class="comment">         * @param[in] resEntries Suchergebnisse</span>
<a name="l00210"></a>00210 <span class="comment">         * @param[in] satzNr int-Wert des Satzes, in dem sich der Token befindet.</span>
<a name="l00211"></a>00211 <span class="comment">         * @param[in] tokenNr int-Wert des Tokens.</span>
<a name="l00212"></a>00212 <span class="comment">         * @param[in] absolute bool-Wert der angibt, ob nach genauer Übereinstimmung oder Extensiv gesucht wird.</span>
<a name="l00213"></a>00213 <span class="comment">         * @param[out] searchResults DataTable-Objekt mit den Suchergebnissen.</span>
<a name="l00214"></a>00214 <span class="comment">        */</span>
<a name="l00215"></a><a class="code" href="class_j_a_d_e_1_1_search_engine.html#a5afb43c7724a532b30eb7d305ab67235">00215</a>         <span class="keyword">private</span> DataTable <a class="code" href="class_j_a_d_e_1_1_search_engine.html#a5afb43c7724a532b30eb7d305ab67235">createResultTable</a>(XElement resEntries, <span class="keywordtype">int</span> satzNr, <span class="keywordtype">int</span> tokenNr, <span class="keywordtype">bool</span> absolute)
<a name="l00216"></a>00216         {
<a name="l00217"></a>00217             <span class="comment">//Speichere die von defineResultTable definierte und zurückgegebene Tabelle in searchResults.</span>
<a name="l00218"></a>00218             DataTable searchResults = <a class="code" href="class_j_a_d_e_1_1_search_engine.html#a32adffbf43cdecde0ccb656ff11cc65f">defineResultTable</a>(<span class="stringliteral">&quot;results_&quot;</span> + satzNr + tokenNr + ((absolute) ? <span class="stringliteral">&quot;_absolute&quot;</span> : <span class="stringliteral">&quot;&quot;</span>));
<a name="l00219"></a>00219             <a class="code" href="class_j_a_d_e_1_1_search_engine.html#a3ca0213ee6de4759d65608a96ae13c69">dataSet</a>.Tables.Add(searchResults); <span class="comment">// Add the new DataTable to the DataSet.</span>
<a name="l00220"></a>00220 
<a name="l00221"></a>00221             <span class="comment">//Zähler für die Spalte &quot;Eintrag&quot;            </span>
<a name="l00222"></a>00222             <span class="keywordtype">int</span> resultCount = 0;
<a name="l00223"></a>00223 
<a name="l00224"></a>00224             <span class="comment">//Durchlaufe alle Elemente, die im XElement resEntries enthalten sind</span>
<a name="l00225"></a>00225             <span class="keywordflow">foreach</span> (XElement resultEntry <span class="keywordflow">in</span> resEntries.Nodes())
<a name="l00226"></a>00226             {
<a name="l00227"></a>00227                 <span class="comment">//Erzeuge eine Instanz der generischen Klasse List vom Typ String, um die einzeln formatierten deutschen Bedeutungen zu speichern.</span>
<a name="l00228"></a>00228                 List&lt;String&gt; senses = <span class="keyword">new</span> List&lt;String&gt;();
<a name="l00229"></a>00229 
<a name="l00230"></a>00230                 <span class="comment">//Zähler für die Bedeutungen eines Ergebniseintrags</span>
<a name="l00231"></a>00231                 <span class="keywordtype">int</span> senseCount = 0;
<a name="l00232"></a>00232 
<a name="l00233"></a>00233                 <span class="comment">//Durchlaufe alle &lt;sense&gt;-Knoten im Element &lt;senses&gt; des Eintrags</span>
<a name="l00234"></a>00234                 <span class="keywordflow">foreach</span> (XElement sense <span class="keywordflow">in</span> resultEntry.Element(<span class="stringliteral">&quot;senses&quot;</span>).Elements(xns + <span class="stringliteral">&quot;sense&quot;</span>))
<a name="l00235"></a>00235                 {
<a name="l00236"></a>00236                     <span class="comment">//Erzeuge eine Instanz der generischen Klasse List vom Typ String, um die einzelnen Alternativen einer deutschen Bedeutung zu speichern.</span>
<a name="l00237"></a>00237                     List&lt;String&gt; transPerSense = <span class="keyword">new</span> List&lt;String&gt;();
<a name="l00238"></a>00238                     <span class="comment">//Diese Variable dient dem Zwischenspeichern von formatiertem Text für eine der Bedeutungen eines Eintrags.</span>
<a name="l00239"></a>00239                     <span class="keywordtype">string</span> senseData = <span class="stringliteral">&quot;&quot;</span>;
<a name="l00240"></a>00240 
<a name="l00241"></a>00241 <span class="preprocessor">                    #region Einzelne &lt;trans&gt;-Knoten-Inhalte durchlaufen</span>
<a name="l00242"></a>00242 <span class="preprocessor"></span>                    <span class="keywordflow">foreach</span> (XElement trans <span class="keywordflow">in</span> sense.Elements(xns + <span class="stringliteral">&quot;trans&quot;</span>))
<a name="l00243"></a>00243                     {
<a name="l00244"></a>00244                         <span class="comment">//Erzeuge eine Instanz der generischen Klasse List vom Typ String, um die einzeln formatierten Elemente eines &lt;trans&gt;-Knotens zu speichern.</span>
<a name="l00245"></a>00245                         List&lt;String&gt; trPerTrans = <span class="keyword">new</span> List&lt;String&gt;();
<a name="l00246"></a>00246                         <span class="comment">//Diese Variable dient dem Zwischenspeichern von formatiertem Text für eine Alternative einer der Bedeutungen eines Eintrags.</span>
<a name="l00247"></a>00247                         <span class="keywordtype">string</span> transData = <span class="stringliteral">&quot;&quot;</span>;
<a name="l00248"></a>00248 
<a name="l00249"></a>00249 <span class="preprocessor">                        #region Einzelne &lt;tr&gt;-Knoten-Inhalte durchlaufen</span>
<a name="l00250"></a>00250 <span class="preprocessor"></span>                        <span class="keywordflow">foreach</span> (XElement tr <span class="keywordflow">in</span> trans.Elements(xns + <span class="stringliteral">&quot;tr&quot;</span>))
<a name="l00251"></a>00251                         {
<a name="l00252"></a>00252                             <span class="comment">//Durchsuche rekursiv die &lt;tr&gt;-Knoten nach weiteren formatierbaren Elementen und speichere den formatierten String in trData.</span>
<a name="l00253"></a>00253                             <span class="keywordtype">string</span> trData = manage_trContent(tr);
<a name="l00254"></a>00254                             <span class="comment">//Falls trData, nachdem Leerzeichen am Ende entfernt wurden, keinen leeren String enthält, so füge ihn der Liste trPerTrans hinzu. </span>
<a name="l00255"></a>00255                             <span class="keywordflow">if</span> ((trData = trData.TrimEnd()) != <span class="stringliteral">&quot;&quot;</span>) trPerTrans.Add(trData);
<a name="l00256"></a>00256                         }
<a name="l00257"></a>00257 <span class="preprocessor">                        #endregion</span>
<a name="l00258"></a>00258 <span class="preprocessor"></span>                        <span class="comment">//Verbinde die Elemente der Liste trPerTrans mit &quot;, &quot; und speichere den sich ergebenden String in transData.</span>
<a name="l00259"></a>00259                         transData = String.Join(<span class="stringliteral">&quot;, &quot;</span>, trPerTrans.ToArray());
<a name="l00260"></a>00260                         <span class="comment">//Falls transData keinen leeren String enthält, dann füge den enthaltenen String zur Liste transPerSense hinzu.</span>
<a name="l00261"></a>00261                         <span class="keywordflow">if</span> (transData != <span class="stringliteral">&quot;&quot;</span>) transPerSense.Add(transData);
<a name="l00262"></a>00262                     }
<a name="l00263"></a>00263 <span class="preprocessor">                    #endregion</span>
<a name="l00264"></a>00264 <span class="preprocessor"></span>                    <span class="comment">//Füge die Alternativen einer Bedeutung (enthalten in der Liste transPerSense) mit dem Trennzeichen &quot;; &quot; zusammen und speichere den formatierten String in senseData.</span>
<a name="l00265"></a>00265                     senseData = String.Join(<span class="stringliteral">&quot;; &quot;</span>, transPerSense.ToArray());<span class="comment"></span>
<a name="l00266"></a>00266 <span class="comment">                    ////Falls senseData keinen leeren String enthält, dann füge den enthaltenen String zusammen mit einer vorangestellten Bedeutungsnummer zur Liste senses hinzu.</span>
<a name="l00267"></a>00267 <span class="comment"></span>                    <span class="keywordflow">if</span> (senseData != <span class="stringliteral">&quot;&quot;</span>) senses.Add(<span class="stringliteral">&quot;(&quot;</span> + ++senseCount + <span class="stringliteral">&quot;) &quot;</span> + senseData);
<a name="l00268"></a>00268                 }
<a name="l00269"></a>00269                 <span class="comment">//Füge der in defineResultTable definierten und dem dataSet hinzugefügten Tabelle eine neue Zeile mit formatierten Daten hinzu.</span>
<a name="l00270"></a>00270                 searchResults.Rows.Add
<a name="l00271"></a>00271                 (
<a name="l00272"></a>00272                     ++resultCount, <span class="comment">//Inkrementiere den Zähler für die Spalte &quot;Eintrag&quot; um 1 und gib die so erhaltene Zahl zurück.</span>
<a name="l00273"></a>00273                     manage_orths(resultEntry.Element(<span class="stringliteral">&quot;orths&quot;</span>)), <span class="comment">//Gib die verschiedenen Schreibweisen formatiert aus.</span>
<a name="l00274"></a>00274                     manage_gramGrpData(resultEntry.Element(xns + <span class="stringliteral">&quot;gramGrp&quot;</span>)), <span class="comment">//Gib die Grammatikinformationen formatiert aus.</span>
<a name="l00275"></a>00275                     manage_prons(resultEntry.Element(<span class="stringliteral">&quot;prons&quot;</span>)), <span class="comment">//Gib die Umschriften formatiert aus.</span>
<a name="l00276"></a>00276                     (String.Join(<span class="stringliteral">&quot;. &quot;</span>, senses) + <span class="stringliteral">&quot;.&quot;</span>) <span class="comment">//Füge die formatierten deutschen Bedeutungen in der Liste senses zusammen. Die Trennzeichen sind &quot;. &quot;.</span>
<a name="l00277"></a>00277                 );
<a name="l00278"></a>00278             }
<a name="l00279"></a>00279             <span class="keywordflow">return</span> searchResults;
<a name="l00280"></a>00280         }
<a name="l00281"></a>00281 <span class="comment"></span>
<a name="l00282"></a>00282 <span class="comment">        /**</span>
<a name="l00283"></a>00283 <span class="comment">         * Diese Funktion definiert für die gefundenen Wörterbucheinträge eine DataTable mit den Spalten für die Eintragsnummer, die Schreibweisen, die Wortart, die Umschrift und die Bedeutungen. Der Name der definierten Tabelle wird durch tableName bestimmt.</span>
<a name="l00284"></a>00284 <span class="comment">         * @param[in] tableName Name der zu erstellenden Table.</span>
<a name="l00285"></a>00285 <span class="comment">         * @param[out] result Die vollständig definierte Tabelle.</span>
<a name="l00286"></a>00286 <span class="comment">         */</span>
<a name="l00287"></a><a class="code" href="class_j_a_d_e_1_1_search_engine.html#a32adffbf43cdecde0ccb656ff11cc65f">00287</a>         <span class="keyword">private</span> DataTable <a class="code" href="class_j_a_d_e_1_1_search_engine.html#a32adffbf43cdecde0ccb656ff11cc65f">defineResultTable</a>(<span class="keywordtype">string</span> tableName)
<a name="l00288"></a>00288         {
<a name="l00289"></a>00289             DataTable result = <span class="keyword">new</span> DataTable(tableName);            <span class="comment">// Erzeugt ein neues DataTable-Objekt für die Suchergebnisse</span>
<a name="l00290"></a>00290             DataColumn column;                                      <span class="comment">// Deklariert eine Hilfsvariable für die Spaltendefinition.</span>
<a name="l00291"></a>00291 
<a name="l00292"></a>00292 
<a name="l00293"></a>00293 
<a name="l00294"></a>00294             column = <span class="keyword">new</span> DataColumn                                 <span class="comment">// Erzeugt eine neue DataColumn, und legt Folgendes fest:</span>
<a name="l00295"></a>00295             {
<a name="l00296"></a>00296                 DataType = System.Type.GetType(<span class="stringliteral">&quot;System.Int32&quot;</span>),     <span class="comment">// Setzt Datentyp auf &quot;int&quot;.</span>
<a name="l00297"></a>00297                 ColumnName = <span class="stringliteral">&quot;Eintrag&quot;</span>,                             <span class="comment">// Der Spaltenname ist &quot;Eintrag&quot;.</span>
<a name="l00298"></a>00298                 ReadOnly = <span class="keyword">true</span>,                                    <span class="comment">// Die Inhalte dieser Spalte können nur gelesen werden.</span>
<a name="l00299"></a>00299             };
<a name="l00300"></a>00300             result.Columns.Add(column);                             <span class="comment">// Fügt die definierte Spalte &quot;Eintrag&quot; zur DataColumnCollection result.Columns hinzu.</span>
<a name="l00301"></a>00301 
<a name="l00302"></a>00302 
<a name="l00303"></a>00303 
<a name="l00304"></a>00304             column = <span class="keyword">new</span> DataColumn                                 <span class="comment">// Erzeugt eine neue DataColumn, und legt Folgendes fest:</span>
<a name="l00305"></a>00305             {
<a name="l00306"></a>00306                 DataType = System.Type.GetType(<span class="stringliteral">&quot;System.String&quot;</span>),    <span class="comment">// Setzt Datentyp auf &quot;String&quot;.</span>
<a name="l00307"></a>00307                 ColumnName = <span class="stringliteral">&quot;Schreibweise&quot;</span>,                        <span class="comment">// Der Spaltenname ist &quot;Schreibweise&quot;.</span>
<a name="l00308"></a>00308                 ReadOnly = <span class="keyword">true</span>,                                    <span class="comment">// Die Inhalte dieser Spalte können nur gelesen werden.</span>
<a name="l00309"></a>00309             };
<a name="l00310"></a>00310             result.Columns.Add(column);                             <span class="comment">// Fügt die definierte Spalte &quot;Schreibweise&quot; zur DataColumnCollection result.Columns hinzu.</span>
<a name="l00311"></a>00311 
<a name="l00312"></a>00312 
<a name="l00313"></a>00313 
<a name="l00314"></a>00314             column = <span class="keyword">new</span> DataColumn                                 <span class="comment">// Erzeugt eine neue DataColumn, und legt Folgendes fest:</span>
<a name="l00315"></a>00315             {
<a name="l00316"></a>00316                 DataType = System.Type.GetType(<span class="stringliteral">&quot;System.String&quot;</span>),    <span class="comment">// Setzt Datentyp auf &quot;String&quot;.</span>
<a name="l00317"></a>00317                 ColumnName = <span class="stringliteral">&quot;Wortart&quot;</span>,                             <span class="comment">// Der Spaltenname ist &quot;Wortart&quot;.</span>
<a name="l00318"></a>00318                 ReadOnly = <span class="keyword">true</span>,                                    <span class="comment">// Die Inhalte dieser Spalte können nur gelesen werden.</span>
<a name="l00319"></a>00319             };
<a name="l00320"></a>00320             result.Columns.Add(column);                             <span class="comment">// Fügt die definierte Spalte &quot;Wortart&quot; zur DataColumnCollection result.Columns hinzu.</span>
<a name="l00321"></a>00321 
<a name="l00322"></a>00322 
<a name="l00323"></a>00323 
<a name="l00324"></a>00324             column = <span class="keyword">new</span> DataColumn                                 <span class="comment">// Erzeugt eine neue DataColumn, und legt Folgendes fest:</span>
<a name="l00325"></a>00325             {
<a name="l00326"></a>00326                 DataType = System.Type.GetType(<span class="stringliteral">&quot;System.String&quot;</span>),    <span class="comment">// Setzt Datentyp auf &quot;String&quot;.</span>
<a name="l00327"></a>00327                 ColumnName = <span class="stringliteral">&quot;Umschrift&quot;</span>,                           <span class="comment">// Der Spaltenname ist &quot;Umschrift&quot;.</span>
<a name="l00328"></a>00328                 ReadOnly = <span class="keyword">true</span>,                                    <span class="comment">// Die Inhalte dieser Spalte können nur gelesen werden.</span>
<a name="l00329"></a>00329             };
<a name="l00330"></a>00330             result.Columns.Add(column);                             <span class="comment">// Fügt die definierte Spalte &quot;Umschrift&quot; zur DataColumnCollection result.Columns hinzu.</span>
<a name="l00331"></a>00331 
<a name="l00332"></a>00332 
<a name="l00333"></a>00333 
<a name="l00334"></a>00334             column = <span class="keyword">new</span> DataColumn                                 <span class="comment">// Erzeugt eine neue DataColumn, und legt Folgendes fest:</span>
<a name="l00335"></a>00335             {
<a name="l00336"></a>00336                 DataType = System.Type.GetType(<span class="stringliteral">&quot;System.String&quot;</span>),    <span class="comment">// Setzt Datentyp auf &quot;String&quot;.</span>
<a name="l00337"></a>00337                 ColumnName = <span class="stringliteral">&quot;Bedeutungen&quot;</span>,                         <span class="comment">// Der Spaltenname ist &quot;Bedeutungen&quot;.</span>
<a name="l00338"></a>00338                 ReadOnly = <span class="keyword">true</span>,                                    <span class="comment">// Die Inhalte dieser Spalte können nur gelesen werden.</span>
<a name="l00339"></a>00339             };
<a name="l00340"></a>00340             result.Columns.Add(column);                             <span class="comment">// Fügt die definierte Spalte &quot;Bedeutungen&quot; zur DataColumnCollection result.Columns hinzu.</span>
<a name="l00341"></a>00341 
<a name="l00342"></a>00342 
<a name="l00343"></a>00343 
<a name="l00344"></a>00344             DataColumn[] PrimaryKeyColumns = <span class="keyword">new</span> DataColumn[1];     <span class="comment">// Erzeugt einen Hilfsarray, der die Schlüsselspalte(n) aufnehmen soll.</span>
<a name="l00345"></a>00345             PrimaryKeyColumns[0] = result.Columns[<span class="stringliteral">&quot;Eintrag&quot;</span>];       <span class="comment">// Speichert die &quot;Eintrag&quot;-Spalte im Hilfsarray ab.</span>
<a name="l00346"></a>00346             result.PrimaryKey = PrimaryKeyColumns;                  <span class="comment">// Markiert die &quot;Eintrag&quot;-Spalte als Primärschlüssel.</span>
<a name="l00347"></a>00347 
<a name="l00348"></a>00348             <span class="keywordflow">return</span> result;                                          <span class="comment">// Gibt die fertig definierte Tabelle &quot;result&quot; zurück.</span>
<a name="l00349"></a>00349         }
<a name="l00350"></a>00350 
<a name="l00351"></a>00351 <span class="comment"></span>
<a name="l00352"></a>00352 <span class="comment">        /// @cond</span>
<a name="l00353"></a>00353 <span class="comment"></span><span class="comment"></span>
<a name="l00354"></a>00354 <span class="comment">        /**</span>
<a name="l00355"></a>00355 <span class="comment">         * Diese Funktion dient der Formatierung der Schreibweisen.</span>
<a name="l00356"></a>00356 <span class="comment">         * @param[in] orth XElement-Objekt, das die Schreibweise-Daten aus einem Eintrag in Wadoku enthält</span>
<a name="l00357"></a>00357 <span class="comment">         * @param[out] orthsString string-Wert mit formatierten Schreibweise-Daten</span>
<a name="l00358"></a>00358 <span class="comment">         */</span>
<a name="l00359"></a>00359         <span class="keyword">private</span> <span class="keywordtype">string</span> manage_orths(XElement orths)
<a name="l00360"></a>00360         {
<a name="l00361"></a>00361             <span class="comment">//Liste für Schreibweise-Textlemente ohne besondere Attribute</span>
<a name="l00362"></a>00362             List&lt;String&gt; orthsData = <span class="keyword">new</span> List&lt;String&gt;();
<a name="l00363"></a>00363             <span class="comment">//Liste für Schreibweise-Textlemente mit besonderen Attributen, die für Redundanz in der Anzeige sorgen</span>
<a name="l00364"></a>00364             List&lt;String&gt; deviatingOrthsData = <span class="keyword">new</span> List&lt;String&gt;();
<a name="l00365"></a>00365 <span class="comment"></span>
<a name="l00366"></a>00366 <span class="comment">            ////Zähler für die einzelnen Schreibweisen</span>
<a name="l00367"></a>00367 <span class="comment"></span>            <span class="keywordtype">int</span> orthCount = 0;
<a name="l00368"></a>00368 
<a name="l00369"></a>00369             <span class="comment">//Zwischenspeicher für die formatierte Schreibweise-Zeichenkette</span>
<a name="l00370"></a>00370             <span class="keywordtype">string</span> orthsString = <span class="stringliteral">&quot;&quot;</span>;
<a name="l00371"></a>00371 
<a name="l00372"></a>00372             <span class="comment">//Durchlaufe alle Schreibweise-Elemente </span>
<a name="l00373"></a>00373             <span class="keywordflow">foreach</span> (XElement orth <span class="keywordflow">in</span> orths.Elements())
<a name="l00374"></a>00374             {
<a name="l00375"></a>00375                 <span class="comment">//Zwischenspeicher für die Zeichenketten in den Schreibweise-Elementen</span>
<a name="l00376"></a>00376                 <span class="keywordtype">string</span> orthData = <span class="stringliteral">&quot;&quot;</span>;
<a name="l00377"></a>00377                 <span class="comment">//Diese Variable wird auf true gesetzt, wenn eine Zeichenkette in die Liste deviatingOrthsData gehört.</span>
<a name="l00378"></a>00378                 <span class="keywordtype">bool</span> variant = <span class="keyword">false</span>;
<a name="l00379"></a>00379 
<a name="l00380"></a>00380                 <span class="comment">//Diese Verzweigungen bereiten die Sortierung der Schreibweise-Elemente in die Listen orthsData und deviatingOrthsData vor. </span>
<a name="l00381"></a>00381                 <span class="keywordflow">if</span> (orth.Attribute(<span class="stringliteral">&quot;midashigo&quot;</span>) == null)
<a name="l00382"></a>00382                 {
<a name="l00383"></a>00383                     <span class="keywordflow">if</span> (orth.Attribute(<span class="stringliteral">&quot;irr&quot;</span>) != null)
<a name="l00384"></a>00384                     {
<a name="l00385"></a>00385                         <span class="keywordflow">if</span> (orth.Value != <span class="stringliteral">&quot;&quot;</span>) orthData = orth.Value;
<a name="l00386"></a>00386                         variant = <span class="keyword">true</span>;
<a name="l00387"></a>00387                     }
<a name="l00388"></a>00388                     <span class="keywordflow">else</span>
<a name="l00389"></a>00389                     {
<a name="l00390"></a>00390                         <span class="keywordflow">if</span> (orth.Value != <span class="stringliteral">&quot;&quot;</span>) orthData = orth.Value;
<a name="l00391"></a>00391                     }
<a name="l00392"></a>00392                 }
<a name="l00393"></a>00393 
<a name="l00394"></a>00394                 <span class="comment">//Falls verwendbare orthData gefunden wurde, ... </span>
<a name="l00395"></a>00395                 <span class="keywordflow">if</span> (orthData != <span class="stringliteral">&quot;&quot;</span>)
<a name="l00396"></a>00396                 {
<a name="l00397"></a>00397                     <span class="keywordflow">if</span> (variant)
<a name="l00398"></a>00398                     {
<a name="l00399"></a>00399                         <span class="comment">// ... werden Schreibweise-Elemente mit besonderen Attributen zunächst in deviatingOrthsData gesammelt</span>
<a name="l00400"></a>00400                         deviatingOrthsData.Add(orthData);
<a name="l00401"></a>00401                     }
<a name="l00402"></a>00402                     <span class="keywordflow">else</span>
<a name="l00403"></a>00403                     {
<a name="l00404"></a>00404                         <span class="comment">// ... werden Schreibweise-Elemente ohne besondere Attribute nummeriert in orthsData gesammelt</span>
<a name="l00405"></a>00405                         orthsData.Add(<span class="stringliteral">&quot;(&quot;</span> + ++orthCount + <span class="stringliteral">&quot;) &quot;</span> + orthData);
<a name="l00406"></a>00406                     }
<a name="l00407"></a>00407                 }
<a name="l00408"></a>00408             }
<a name="l00409"></a>00409 
<a name="l00410"></a>00410             <span class="comment">//Schreibweise-Elemente mit besonderen Attributen werden jetzt durchnummeriert in der Liste NumberedDeviatingOrthsData gespeichert</span>
<a name="l00411"></a>00411             List&lt;String&gt; NumberedDeviatingOrthsData = <span class="keyword">new</span> List&lt;String&gt;();
<a name="l00412"></a>00412 
<a name="l00413"></a>00413             <span class="keywordflow">foreach</span> (var deviatingOrth <span class="keywordflow">in</span> deviatingOrthsData)
<a name="l00414"></a>00414             {
<a name="l00415"></a>00415                 NumberedDeviatingOrthsData.Add(<span class="stringliteral">&quot;(&quot;</span> + ++orthCount + <span class="stringliteral">&quot;) &quot;</span> + deviatingOrth);
<a name="l00416"></a>00416             }
<a name="l00417"></a>00417 
<a name="l00418"></a>00418             <span class="comment">//zuerst werden die Schreibweise-Elemente ohne besondere Attribute zusammengefügt, dann folgen die Schreibweise-Elemente mit besonderen Attributen (falls welche vorhanden sind) in eckigen Klammern. </span>
<a name="l00419"></a>00419             <span class="comment">//Trennzeichen sind in beiden Fällen &quot;; &quot;.</span>
<a name="l00420"></a>00420             orthsString = String.Join(<span class="stringliteral">&quot;; &quot;</span>, orthsData) + ((NumberedDeviatingOrthsData.Count &gt; 0) ? (<span class="stringliteral">&quot;; [auch: &quot;</span> + String.Join(<span class="stringliteral">&quot;; &quot;</span>, NumberedDeviatingOrthsData) + <span class="stringliteral">&quot;]&quot;</span>) : <span class="stringliteral">&quot;&quot;</span>);
<a name="l00421"></a>00421             
<a name="l00422"></a>00422             <span class="comment">//Die mit dieser Formattierung in orthsString gespeicherte Zeichenkette wird nun zurückgegeben.</span>
<a name="l00423"></a>00423             <span class="keywordflow">return</span> orthsString;
<a name="l00424"></a>00424         }
<a name="l00425"></a>00425 <span class="comment"></span>
<a name="l00426"></a>00426 <span class="comment">        /**</span>
<a name="l00427"></a>00427 <span class="comment">         * Diese Funktion dient der Formatierung der grammatischen Informationen</span>
<a name="l00428"></a>00428 <span class="comment">         * @param[in] gramGrp orth XElement-Objekt, das die grammatischen Informationen aus einem Eintrag in Wadoku enthält</span>
<a name="l00429"></a>00429 <span class="comment">         * @param[out] string-Wert mit formatierten Schreibweise-Daten</span>
<a name="l00430"></a>00430 <span class="comment">         */</span>
<a name="l00431"></a>00431         <span class="keyword">private</span> <span class="keywordtype">string</span> manage_gramGrpData(XElement gramGrp)
<a name="l00432"></a>00432         {
<a name="l00433"></a>00433             <span class="comment">//Liste für Schreibweise-Textelemente ohne besondere Attribute</span>
<a name="l00434"></a>00434             List&lt;String&gt; gramGrpData = <span class="keyword">new</span> List&lt;String&gt;();
<a name="l00435"></a>00435             <span class="comment">//Zwischenspeicher für die formatierte grammatische Informationen</span>
<a name="l00436"></a>00436             <span class="keywordtype">string</span> gramGrpString = <span class="stringliteral">&quot;&quot;</span>;
<a name="l00437"></a>00437 
<a name="l00438"></a>00438             <span class="comment">//Dummy-Element, das XML-Elemente aufsammelt, die (noch) nicht gesondert bei der Formatierung behandelt werden (Wadoku-Eintragsstruktur teilweise unklar, oder aber explizit als in Zukunft erweiterbar beschrieben)</span>
<a name="l00439"></a>00439             XElement trDummy = <span class="keyword">new</span> XElement(<span class="stringliteral">&quot;tr&quot;</span>);
<a name="l00440"></a>00440 
<a name="l00441"></a>00441             <span class="comment">//Zwischenspeicher für die formatierte grammatische Informationen eines Elements im &lt;gramGrp&gt;-Knoten</span>
<a name="l00442"></a>00442             <span class="keywordtype">string</span> posData = <span class="stringliteral">&quot;&quot;</span>;
<a name="l00443"></a>00443 
<a name="l00444"></a>00444             <span class="comment">//Falls &lt;gramGrp&gt;-Knoten vorhanden ist ... </span>
<a name="l00445"></a>00445             <span class="keywordflow">if</span> (gramGrp != null)
<a name="l00446"></a>00446             {
<a name="l00447"></a>00447                 <span class="comment">// ... durchlaufe alle Elemente auf der nächsttieferen Ebene, ...</span>
<a name="l00448"></a>00448                 <span class="keywordflow">foreach</span> (XElement elem <span class="keywordflow">in</span> gramGrp.Elements())
<a name="l00449"></a>00449                 {
<a name="l00450"></a>00450                     <span class="comment">//Setze posData auf den leeren String</span>
<a name="l00451"></a>00451                     posData = <span class="stringliteral">&quot;&quot;</span>;
<a name="l00452"></a>00452 
<a name="l00453"></a>00453                     <span class="comment">//Falls es sich um POS-Informationen handelt, ...</span>
<a name="l00454"></a>00454                     <span class="keywordflow">if</span> (elem.Name == xns + <span class="stringliteral">&quot;pos&quot;</span>)
<a name="l00455"></a>00455                     {
<a name="l00456"></a>00456                         <span class="comment">// ... formatiere, falls vorhanden, die Inhalte des trDummy-Elements mittels manage_trContent.</span>
<a name="l00457"></a>00457                         <span class="keywordflow">if</span> (trDummy.Elements().Count() &gt; 0)
<a name="l00458"></a>00458                         {
<a name="l00459"></a>00459                             <span class="keywordflow">if</span> ((posData = manage_trContent(trDummy)) != <span class="stringliteral">&quot;&quot;</span>)
<a name="l00460"></a>00460                             {
<a name="l00461"></a>00461                                 gramGrpData.Add(posData); <span class="comment">//Füge formatierte Daten der Liste hinzu</span>
<a name="l00462"></a>00462 
<a name="l00463"></a>00463                                 <span class="comment">//Setze Hilfsvariablen zurück</span>
<a name="l00464"></a>00464                                 posData = <span class="stringliteral">&quot;&quot;</span>;
<a name="l00465"></a>00465                                 trDummy = <span class="keyword">new</span> XElement(<span class="stringliteral">&quot;tr&quot;</span>);
<a name="l00466"></a>00466                             }
<a name="l00467"></a>00467                         }
<a name="l00468"></a>00468                         <span class="comment">// ... und falls das POS-Element Attribute besitzt ...</span>
<a name="l00469"></a>00469                         <span class="keywordflow">if</span> (elem.HasAttributes)
<a name="l00470"></a>00470                         {
<a name="l00471"></a>00471                             <span class="comment">// .... und das Attribut type vorhanden ist, ...</span>
<a name="l00472"></a>00472                             <span class="keywordflow">if</span> (elem.Attribute(<span class="stringliteral">&quot;type&quot;</span>) != null)
<a name="l00473"></a>00473                             {
<a name="l00474"></a>00474                                 <span class="comment">// ... so formatiere die POS-Infos mit der Hashtable posDeciphering.</span>
<a name="l00475"></a>00475                                 posData = (string)posDeciphering[elem.Attribute(<span class="stringliteral">&quot;type&quot;</span>).Value];
<a name="l00476"></a>00476                             }
<a name="l00477"></a>00477                             <span class="comment">//Überprüfung des POS-Elements auf untergeordnete Elemente</span>
<a name="l00478"></a>00478                             <span class="keywordflow">if</span> (elem.HasElements)
<a name="l00479"></a>00479                             {
<a name="l00480"></a>00480                                 <span class="comment">//Füge eventuell vorhandene ergänzende Daten nach einem Doppelpunkt den POS-Infos hinzu</span>
<a name="l00481"></a>00481                                 <span class="keywordtype">string</span> posDescendantsData = <span class="stringliteral">&quot;&quot;</span>;
<a name="l00482"></a>00482                                 posData += ((posDescendantsData = manage_trContent(elem)) != <span class="stringliteral">&quot;&quot;</span>)
<a name="l00483"></a>00483                                             ? (<span class="stringliteral">&quot;: &quot;</span> + posDescendantsData) : <span class="stringliteral">&quot;&quot;</span>;
<a name="l00484"></a>00484                             }
<a name="l00485"></a>00485                         }
<a name="l00486"></a>00486                         <span class="comment">//Falls posData nicht leer ist, sammle die Daten in der Liste gramGrpData</span>
<a name="l00487"></a>00487                         <span class="keywordflow">if</span> (posData != <span class="stringliteral">&quot;&quot;</span>) gramGrpData.Add(posData);
<a name="l00488"></a>00488                     }
<a name="l00489"></a>00489                     <span class="comment">//Aufsammlung der XML-Elemente, die nicht POS-Elemente sind und (noch) nicht gesondert bei der Formatierung behandelt werden</span>
<a name="l00490"></a>00490                     <span class="keywordflow">else</span>
<a name="l00491"></a>00491                     {
<a name="l00492"></a>00492                         trDummy.Add(elem);
<a name="l00493"></a>00493                     }
<a name="l00494"></a>00494                 }
<a name="l00495"></a>00495                 <span class="comment">//Falls trDummy nach dem Ende der foreach-Schleife nicht leer ist, formatiere die noch vorhandenen Daten</span>
<a name="l00496"></a>00496                 <span class="keywordflow">if</span> (trDummy.Elements().Count() &gt; 0)
<a name="l00497"></a>00497                 {
<a name="l00498"></a>00498                     <span class="keywordflow">if</span> ((posData = manage_trContent(trDummy)) != <span class="stringliteral">&quot;&quot;</span>) gramGrpData.Add(posData);
<a name="l00499"></a>00499                 }
<a name="l00500"></a>00500             }
<a name="l00501"></a>00501             <span class="comment">//Falls gramGrpData Strings enthält, füge sie getrennt durch &quot;; &quot; und hänge ein weiteres &quot;;&quot; hinten an und gib diesen String zurück. gib ansonsten einen leeren String zurück.</span>
<a name="l00502"></a>00502             <span class="keywordflow">return</span> ((gramGrpString = String.Join(<span class="stringliteral">&quot;; &quot;</span>, gramGrpData)) != <span class="stringliteral">&quot;&quot;</span>) ? (gramGrpString + <span class="stringliteral">&quot;;&quot;</span>) : <span class="stringliteral">&quot;&quot;</span>;
<a name="l00503"></a>00503         }
<a name="l00504"></a>00504 <span class="comment"></span>
<a name="l00505"></a>00505 <span class="comment">        /**</span>
<a name="l00506"></a>00506 <span class="comment">         * Diese Funktion dient der Formatierung der Umschriften.</span>
<a name="l00507"></a>00507 <span class="comment">         * @param[in] prons XElement-Objekt, das die Umschriften aus einem Eintrag in Wadoku enthält</span>
<a name="l00508"></a>00508 <span class="comment">         * @param[out] pronsString string-Wert mit formatierten Umschrift-Daten</span>
<a name="l00509"></a>00509 <span class="comment">         */</span>
<a name="l00510"></a>00510         <span class="keyword">private</span> <span class="keywordtype">string</span> manage_prons(XElement prons)
<a name="l00511"></a>00511         {
<a name="l00512"></a>00512 
<a name="l00513"></a>00513             <span class="comment">//Der Aufbau dieser Funktion ist analog zu der für die Schreibweise-Daten</span>
<a name="l00514"></a>00514 
<a name="l00515"></a>00515             List&lt;String&gt; pronsData = <span class="keyword">new</span> List&lt;String&gt;();
<a name="l00516"></a>00516             List&lt;String&gt; deviatingPronsData = <span class="keyword">new</span> List&lt;String&gt;();
<a name="l00517"></a>00517 
<a name="l00518"></a>00518             <span class="keywordtype">int</span> pronCount = 0;
<a name="l00519"></a>00519             <span class="keywordtype">string</span> pronsString = <span class="stringliteral">&quot;&quot;</span>;
<a name="l00520"></a>00520 
<a name="l00521"></a>00521             <span class="keywordflow">foreach</span> (XElement pron <span class="keywordflow">in</span> prons.Elements())
<a name="l00522"></a>00522             {
<a name="l00523"></a>00523                 <span class="keywordtype">string</span> pronData = <span class="stringliteral">&quot;&quot;</span>;
<a name="l00524"></a>00524                 <span class="keywordtype">bool</span> variant = <span class="keyword">false</span>;
<a name="l00525"></a>00525 
<a name="l00526"></a>00526                 <span class="keywordflow">if</span> (pron.Attribute(<span class="stringliteral">&quot;type&quot;</span>) != null)
<a name="l00527"></a>00527                 {
<a name="l00528"></a>00528                     <span class="keywordflow">if</span> (pron.Attribute(<span class="stringliteral">&quot;type&quot;</span>).Value == <span class="stringliteral">&quot;romaji&quot;</span>)
<a name="l00529"></a>00529                     {
<a name="l00530"></a>00530                         <span class="keywordflow">if</span> (pron.Value != <span class="stringliteral">&quot;&quot;</span>) pronData = pron.Value;
<a name="l00531"></a>00531                         variant = <span class="keyword">true</span>;
<a name="l00532"></a>00532                     }
<a name="l00533"></a>00533                 }
<a name="l00534"></a>00534                 <span class="keywordflow">else</span>
<a name="l00535"></a>00535                 {
<a name="l00536"></a>00536                     <span class="keywordflow">if</span> (pron.Value != <span class="stringliteral">&quot;&quot;</span>) pronData = pron.Value;
<a name="l00537"></a>00537                 }
<a name="l00538"></a>00538 
<a name="l00539"></a>00539                 <span class="keywordflow">if</span> (pronData != <span class="stringliteral">&quot;&quot;</span>)
<a name="l00540"></a>00540                 {
<a name="l00541"></a>00541                     <span class="keywordflow">if</span> (variant)
<a name="l00542"></a>00542                     {
<a name="l00543"></a>00543                         deviatingPronsData.Add(pronData);
<a name="l00544"></a>00544                     }
<a name="l00545"></a>00545                     <span class="keywordflow">else</span>
<a name="l00546"></a>00546                     {
<a name="l00547"></a>00547                         pronsData.Add(<span class="stringliteral">&quot;(&quot;</span> + ++pronCount + <span class="stringliteral">&quot;) &quot;</span> + pronData);
<a name="l00548"></a>00548                     }
<a name="l00549"></a>00549                 }
<a name="l00550"></a>00550             }
<a name="l00551"></a>00551 
<a name="l00552"></a>00552             List&lt;String&gt; NumberedDeviatingPronsData = <span class="keyword">new</span> List&lt;String&gt;();
<a name="l00553"></a>00553 
<a name="l00554"></a>00554             <span class="keywordflow">foreach</span> (var deviatingPron <span class="keywordflow">in</span> deviatingPronsData)
<a name="l00555"></a>00555             {
<a name="l00556"></a>00556                 NumberedDeviatingPronsData.Add(<span class="stringliteral">&quot;(&quot;</span> + ++pronCount + <span class="stringliteral">&quot;) &quot;</span> + deviatingPron);
<a name="l00557"></a>00557             }
<a name="l00558"></a>00558 
<a name="l00559"></a>00559             pronsString = String.Join(<span class="stringliteral">&quot;; &quot;</span>, pronsData) + ((deviatingPronsData.Count &gt; 0) ? (<span class="stringliteral">&quot;; [Romaji: &quot;</span> + String.Join(<span class="stringliteral">&quot;; &quot;</span>, NumberedDeviatingPronsData) + <span class="stringliteral">&quot;]&quot;</span>) : <span class="stringliteral">&quot;&quot;</span>);
<a name="l00560"></a>00560             <span class="keywordflow">return</span> pronsString;
<a name="l00561"></a>00561         }
<a name="l00562"></a>00562 <span class="comment"></span>
<a name="l00563"></a>00563 <span class="comment">        /**</span>
<a name="l00564"></a>00564 <span class="comment">         * Diese Funktion dient der Formatierung der Informationen in &lt;tr&gt;-Elementen. Da sie eine rekursive Funktion aufruft, die flexibel auch tiefere Ebenen in der XML-Struktur durchsucht, wird sie auch stellenweise für Knoten verwendet, die keine &lt;tr&gt;-Knoten sind.</span>
<a name="l00565"></a>00565 <span class="comment">         * @param[in] tr XElement-Objekt, dessen Text-Inhalte formatiert werden sollen</span>
<a name="l00566"></a>00566 <span class="comment">         * @param[out] trData string-Wert, der die formatierten Texte für das &lt;tr&gt;-Element enthält</span>
<a name="l00567"></a>00567 <span class="comment">         */</span>
<a name="l00568"></a>00568         <span class="keyword">private</span> <span class="keywordtype">string</span> manage_trContent(XElement tr)
<a name="l00569"></a>00569         {
<a name="l00570"></a>00570             <span class="comment">//verschiedene bool-Varaiblen, die dazu dienen, Attribute für Whitespace aus den Wadoku-Einträgen richtig zu beachten</span>
<a name="l00571"></a>00571             <span class="keywordtype">bool</span> first = <span class="keyword">true</span>; <span class="comment">//hält fest, ob das gerade betrachtete Element das erste innerhalb des &lt;tr&gt;-Elements ist</span>
<a name="l00572"></a>00572             <span class="keywordtype">bool</span> followingSpaceOld = <span class="keyword">false</span>;
<a name="l00573"></a>00573             <span class="keywordtype">bool</span> followingSpaceNew = <span class="keyword">false</span>;
<a name="l00574"></a>00574             <span class="keywordtype">bool</span> preceedingSpace = <span class="keyword">false</span>;
<a name="l00575"></a>00575 
<a name="l00576"></a>00576             <span class="comment">//Liste für Textelemente in einem &lt;tr&gt;-Element</span>
<a name="l00577"></a>00577             List&lt;String&gt; elemPerTr = <span class="keyword">new</span> List&lt;String&gt;();
<a name="l00578"></a>00578             <span class="comment">//Zwischenspeicher für die formatierten Texte des &lt;tr&gt;-Elements</span>
<a name="l00579"></a>00579             <span class="keywordtype">string</span> trData = <span class="stringliteral">&quot;&quot;</span>;
<a name="l00580"></a>00580 
<a name="l00581"></a>00581             <span class="comment">//Durchlaufe alle dem &lt;tr&gt;-Element untergeordneten Elemente</span>
<a name="l00582"></a>00582             <span class="keywordflow">foreach</span> (XElement elem <span class="keywordflow">in</span> tr.Elements())
<a name="l00583"></a>00583             {
<a name="l00584"></a>00584                 <span class="comment">//Zwischenspeicher für die formatierten Texte von einem dem &lt;tr&gt;-Element untergeordneten Element</span>
<a name="l00585"></a>00585                 <span class="keywordtype">string</span> elemData = <span class="stringliteral">&quot;&quot;</span>;
<a name="l00586"></a>00586 
<a name="l00587"></a>00587                 <span class="comment">//Bei &lt;text&gt;-Elementen müssen die Whitespace-Attribute behandelt werden</span>
<a name="l00588"></a>00588                 <span class="keywordflow">if</span> (elem.Name == xns + <span class="stringliteral">&quot;text&quot;</span>)
<a name="l00589"></a>00589                 {
<a name="l00590"></a>00590                     <span class="keywordflow">if</span> (elem.Attribute(<span class="stringliteral">&quot;hasPrecedingSpace&quot;</span>) != null)
<a name="l00591"></a>00591                     {
<a name="l00592"></a>00592                         <span class="keywordflow">if</span> (elem.Attribute(<span class="stringliteral">&quot;hasPrecedingSpace&quot;</span>).Value == <span class="stringliteral">&quot;true&quot;</span>)
<a name="l00593"></a>00593                         {
<a name="l00594"></a>00594                             preceedingSpace = <span class="keyword">true</span>;
<a name="l00595"></a>00595                         }
<a name="l00596"></a>00596                     }
<a name="l00597"></a>00597                     <span class="keywordflow">if</span> (elem.Attribute(<span class="stringliteral">&quot;hasFollowingSpace&quot;</span>) != null)
<a name="l00598"></a>00598                     {
<a name="l00599"></a>00599                         <span class="keywordflow">if</span> (elem.Attribute(<span class="stringliteral">&quot;hasFollowingSpace&quot;</span>).Value == <span class="stringliteral">&quot;true&quot;</span>)
<a name="l00600"></a>00600                         {
<a name="l00601"></a>00601                             followingSpaceNew = <span class="keyword">true</span>;
<a name="l00602"></a>00602                         }
<a name="l00603"></a>00603                     }
<a name="l00604"></a>00604                     elemData = elem.Value; <span class="comment">//Übernehme den Text-Inhalt des XML-Elements</span>
<a name="l00605"></a>00605                 }
<a name="l00606"></a>00606 
<a name="l00607"></a>00607                 <span class="comment">//Token-Elemente sind die zentralen Elemente einer Alternative innerhalb einer Bedeutung eines Eintrags, daher ... </span>
<a name="l00608"></a>00608                 <span class="keywordflow">else</span> <span class="keywordflow">if</span> (elem.Name == xns + <span class="stringliteral">&quot;token&quot;</span>)
<a name="l00609"></a>00609                 {
<a name="l00610"></a>00610                     <span class="keywordtype">string</span> tokenInfo = <span class="stringliteral">&quot;&quot;</span>;
<a name="l00611"></a>00611 
<a name="l00612"></a>00612                     <span class="comment">// ... sind eventuell Genus- und Numerusinformationen in Attributen vorhanden, ...</span>
<a name="l00613"></a>00613                     <span class="keywordflow">if</span> (elem.Attribute(<span class="stringliteral">&quot;type&quot;</span>) != null)
<a name="l00614"></a>00614                     {
<a name="l00615"></a>00615 
<a name="l00616"></a>00616                         <span class="keywordflow">if</span> (elem.Attribute(<span class="stringliteral">&quot;type&quot;</span>).Value == <span class="stringliteral">&quot;N&quot;</span>)
<a name="l00617"></a>00617                         {
<a name="l00618"></a>00618                             <span class="keywordtype">string</span> numerus = <span class="stringliteral">&quot;&quot;</span>;
<a name="l00619"></a>00619                             <span class="keywordtype">string</span> genus = <span class="stringliteral">&quot;&quot;</span>;
<a name="l00620"></a>00620 
<a name="l00621"></a>00621                             <span class="comment">// ... die in dieser Schleife herausgefiltert werden.</span>
<a name="l00622"></a>00622                             <span class="keywordflow">foreach</span> (XAttribute attr <span class="keywordflow">in</span> elem.Attributes())
<a name="l00623"></a>00623                             {
<a name="l00624"></a>00624                                 <span class="keywordflow">switch</span> (attr.Name.ToString())
<a name="l00625"></a>00625                                 {
<a name="l00626"></a>00626                                     <span class="keywordflow">case</span> <span class="stringliteral">&quot;genus&quot;</span>:
<a name="l00627"></a>00627                                         genus = elem.Attribute(<span class="stringliteral">&quot;genus&quot;</span>).Value; <span class="keywordflow">break</span>;
<a name="l00628"></a>00628                                     <span class="keywordflow">case</span> <span class="stringliteral">&quot;numerus&quot;</span>:
<a name="l00629"></a>00629                                         numerus = (elem.Attribute(<span class="stringliteral">&quot;numerus&quot;</span>).Value == <span class="stringliteral">&quot;pl&quot;</span>) ? <span class="stringliteral">&quot;Pl.&quot;</span> : <span class="stringliteral">&quot;Sg.&quot;</span>; <span class="keywordflow">break</span>;
<a name="l00630"></a>00630                                 }
<a name="l00631"></a>00631                             }
<a name="l00632"></a>00632 
<a name="l00633"></a>00633                             <span class="comment">//Diese Verzweigung formatiert die gefundenen Informationen entsprechend in einem Klammerausdruck, ...</span>
<a name="l00634"></a>00634                             <span class="keywordflow">if</span> (genus != <span class="stringliteral">&quot;&quot;</span>)
<a name="l00635"></a>00635                             {
<a name="l00636"></a>00636                                 tokenInfo = <span class="stringliteral">&quot;{&quot;</span> + genus + <span class="stringliteral">&quot;.&quot;</span>;
<a name="l00637"></a>00637                                 <span class="keywordflow">if</span> (numerus != <span class="stringliteral">&quot;&quot;</span>) tokenInfo += <span class="stringliteral">&quot;, &quot;</span> + numerus;
<a name="l00638"></a>00638                                 tokenInfo += <span class="stringliteral">&quot;}&quot;</span>;
<a name="l00639"></a>00639                             }
<a name="l00640"></a>00640                             <span class="keywordflow">else</span>
<a name="l00641"></a>00641                             {
<a name="l00642"></a>00642                                 <span class="keywordflow">if</span> (numerus != <span class="stringliteral">&quot;&quot;</span>) tokenInfo = <span class="stringliteral">&quot;{&quot;</span> + numerus + <span class="stringliteral">&quot;}&quot;</span>;
<a name="l00643"></a>00643                             }
<a name="l00644"></a>00644                         }
<a name="l00645"></a>00645                     }
<a name="l00646"></a>00646 
<a name="l00647"></a>00647                     <span class="comment">//... der dann dem Text im gerade betrachteten &lt;token&gt;-Element angehängt wird.</span>
<a name="l00648"></a>00648                     elemData = elem.Value + tokenInfo;
<a name="l00649"></a>00649                 }
<a name="l00650"></a>00650 
<a name="l00651"></a>00651                 <span class="comment">//Hier werden mit der rekursiven Funktion manage_bracketData Daten formatiert (falls vorhanden, werden sie in Klammern eingefasst), die in einem &lt;bracket&gt;-Element auftauchen.</span>
<a name="l00652"></a>00652                 <span class="keywordflow">else</span> <span class="keywordflow">if</span> (elem.Name == xns + <span class="stringliteral">&quot;bracket&quot;</span>)
<a name="l00653"></a>00653                 {
<a name="l00654"></a>00654                     <span class="keywordtype">string</span> bracketContent = manage_bracketData(elem);
<a name="l00655"></a>00655                     <span class="keywordflow">if</span> (bracketContent != <span class="stringliteral">&quot;&quot;</span>) elemData = <span class="stringliteral">&quot;(&quot;</span> + bracketContent + <span class="stringliteral">&quot;)&quot;</span>;
<a name="l00656"></a>00656                 }
<a name="l00657"></a>00657 
<a name="l00658"></a>00658                 <span class="comment">//eine flexible, rekursive Funktion, durchsucht Elemente anderen Typs auf weitere Informationen</span>
<a name="l00659"></a>00659                 <span class="keywordflow">else</span>
<a name="l00660"></a>00660                 {
<a name="l00661"></a>00661                     <span class="keywordtype">string</span> otherContent = manage_otherData(elem);
<a name="l00662"></a>00662                     <span class="keywordflow">if</span> (otherContent != <span class="stringliteral">&quot;&quot;</span>) elemData = otherContent;
<a name="l00663"></a>00663                 }
<a name="l00664"></a>00664 
<a name="l00665"></a>00665                 <span class="comment">//In den folgenden Verzweigungen wird trData die gesammelte elemData (falls vorhanden) angehängt. Dabei werden eventuell beobachtete Whitespace-Anforderungen umgesetzt.</span>
<a name="l00666"></a>00666                 <span class="keywordflow">if</span> (!(elemData == <span class="stringliteral">&quot;&quot;</span>))
<a name="l00667"></a>00667                 {
<a name="l00668"></a>00668                     <span class="comment">//Hier wird für das erste dem &lt;tr&gt;-Element untergeordnete Element im Bezug auf Whitespace-Attribute nur das hasFollowingSpace-Attribut umgesetzt, falls vorhanden.</span>
<a name="l00669"></a>00669                     <span class="keywordflow">if</span> (first)
<a name="l00670"></a>00670                     {
<a name="l00671"></a>00671                         trData += elemData + ((followingSpaceNew) ? <span class="stringliteral">&quot; &quot;</span> : <span class="stringliteral">&quot;&quot;</span>);
<a name="l00672"></a>00672                         first = <span class="keyword">false</span>;
<a name="l00673"></a>00673                     }
<a name="l00674"></a>00674 
<a name="l00675"></a>00675                     <span class="comment">//Mit allen folgenden Elementen wird so verfahren:</span>
<a name="l00676"></a>00676                     <span class="keywordflow">else</span>
<a name="l00677"></a>00677                     {
<a name="l00678"></a>00678                         <span class="keywordflow">if</span> (!followingSpaceOld)         <span class="comment">// Falls das vorherige Element kein Leerzeichen am Ende aufweist, ...</span>
<a name="l00679"></a>00679                         {
<a name="l00680"></a>00680                             <span class="keywordflow">if</span> (!preceedingSpace)           <span class="comment">// ... und falls das gerade betrachtete Element auch kein führendes Leerzeichen erhalten soll, ...</span>
<a name="l00681"></a>00681                             {
<a name="l00682"></a>00682                                 trData += ((elemData.StartsWith(<span class="stringliteral">&quot;, &quot;</span>)) ? <span class="stringliteral">&quot;&quot;</span> : <span class="stringliteral">&quot;, &quot;</span>);        <span class="comment">// ... so füge, falls nicht bereits vorhanden, &quot;, &quot; als Trennelement ein.</span>
<a name="l00683"></a>00683                             }
<a name="l00684"></a>00684                             <span class="keywordflow">else</span>                            <span class="comment">// ... und falls das gerade betrachtete Element ein führendes Leerzeichen erhalten soll, ...</span>
<a name="l00685"></a>00685                             {
<a name="l00686"></a>00686                                 trData += <span class="stringliteral">&quot; &quot;</span>;                                              <span class="comment">// ... so füge das führende Leerzeichen ein.</span>
<a name="l00687"></a>00687                             }
<a name="l00688"></a>00688                         }
<a name="l00689"></a>00689                         trData += elemData + ((followingSpaceNew) ? <span class="stringliteral">&quot; &quot;</span> : <span class="stringliteral">&quot;&quot;</span>); <span class="comment">//Falls nötig, füge ein folgendes Leerzeichen hinzu.</span>
<a name="l00690"></a>00690                     }
<a name="l00691"></a>00691 
<a name="l00692"></a>00692                     <span class="comment">//Aktualisiere/Setze die Flaggen für folgende Elemente zurück. first wird natürlich nicht zurück auf true gesetzt. </span>
<a name="l00693"></a>00693                     followingSpaceOld = followingSpaceNew;
<a name="l00694"></a>00694                     followingSpaceNew = <span class="keyword">false</span>;
<a name="l00695"></a>00695                     preceedingSpace = <span class="keyword">false</span>;
<a name="l00696"></a>00696                 }
<a name="l00697"></a>00697             }
<a name="l00698"></a>00698             <span class="comment">//Gib die gesammelte trData-Zeichenkette zurück.</span>
<a name="l00699"></a>00699             <span class="keywordflow">return</span> trData;
<a name="l00700"></a>00700         }
<a name="l00701"></a>00701 <span class="comment"></span>
<a name="l00702"></a>00702 <span class="comment">        /**</span>
<a name="l00703"></a>00703 <span class="comment">         * Diese Funktion sammelt flexibel und rekursiv auf tieferen Ebenen formatierte Textdaten innerhalb von &lt;bracket&gt;-Elementen</span>
<a name="l00704"></a>00704 <span class="comment">         * @param[in] bracket XElement-Objekt, das das zu durchsuchende &lt;bracket&gt;-Element darstellt</span>
<a name="l00705"></a>00705 <span class="comment">         * @param[out] string-Wert, der die Daten innerhalb der Klammern zurückliefert</span>
<a name="l00706"></a>00706 <span class="comment">         */</span>
<a name="l00707"></a>00707         <span class="keyword">private</span> <span class="keywordtype">string</span> manage_bracketData(XElement bracket)
<a name="l00708"></a>00708         {
<a name="l00709"></a>00709             <span class="comment">//Liste für Texte aus Elementen, die dem &lt;bracket&gt;-Element direkt untergeordnet sind. </span>
<a name="l00710"></a>00710             List&lt;String&gt; elemsPerBracket = <span class="keyword">new</span> List&lt;String&gt;();
<a name="l00711"></a>00711 
<a name="l00712"></a>00712             <span class="comment">//Falls Elemente in der Klammer vorhanden sind, ...</span>
<a name="l00713"></a>00713             <span class="keywordflow">if</span> (bracket.HasElements)
<a name="l00714"></a>00714             {
<a name="l00715"></a>00715                 <span class="comment">// ... so durchlaufe sie ...</span>
<a name="l00716"></a>00716                 <span class="keywordflow">foreach</span> (XElement bracketElem <span class="keywordflow">in</span> bracket.Elements())
<a name="l00717"></a>00717                 {
<a name="l00718"></a>00718                     <span class="comment">// ... und sammle mit manage_otherData alle enthaltenen Texte, auch auf tieferen Ebenen in der XML-Struktur.</span>
<a name="l00719"></a>00719                     <span class="keywordtype">string</span> bracketElemContent = manage_otherData(bracketElem);
<a name="l00720"></a>00720                     <span class="comment">//Wenn Texte gefunden wurden, sammle sie in der dafür vorgesehenen Liste elemsPerBracket.</span>
<a name="l00721"></a>00721                     <span class="keywordflow">if</span> (bracketElemContent != <span class="stringliteral">&quot;&quot;</span>) elemsPerBracket.Add(bracketElemContent);
<a name="l00722"></a>00722                 }
<a name="l00723"></a>00723             }
<a name="l00724"></a>00724             <span class="comment">//Hier wird der Text des &lt;bracket&gt;-Elements gesammelt, falls es keine untergeordneten Elemente besitzt und falls ein solcher Text vorhanden ist.</span>
<a name="l00725"></a>00725             <span class="keywordflow">else</span>
<a name="l00726"></a>00726             {
<a name="l00727"></a>00727                 <span class="keywordflow">if</span> (bracket.Value != <span class="stringliteral">&quot;&quot;</span>) elemsPerBracket.Add(bracket.Value);
<a name="l00728"></a>00728             }
<a name="l00729"></a>00729             <span class="comment">//Kombiniere die Texte in elemsPerBracket mit &quot;; &quot; und gib den so erhaltenen String zurück.</span>
<a name="l00730"></a>00730             <span class="keywordflow">return</span> String.Join(<span class="stringliteral">&quot;; &quot;</span>, elemsPerBracket);
<a name="l00731"></a>00731         }
<a name="l00732"></a>00732 <span class="comment"></span>
<a name="l00733"></a>00733 <span class="comment">        /**</span>
<a name="l00734"></a>00734 <span class="comment">        * Diese Funktion sammelt flexibel und rekursiv auf tieferen Ebenen formatierte Textdaten innerhalb von XML-Elementen, die nicht gesondert in anderen Funktionen behandelt werden.</span>
<a name="l00735"></a>00735 <span class="comment">        * @param[in] other XElement-Objekt, das das zu durchsuchende XML-Element darstellt</span>
<a name="l00736"></a>00736 <span class="comment">        * @param[out] string-Wert, der die Daten innerhalb des übergebenen Elements zurückliefert</span>
<a name="l00737"></a>00737 <span class="comment">        */</span>
<a name="l00738"></a>00738         <span class="keyword">private</span> <span class="keywordtype">string</span> manage_otherData(XElement other)
<a name="l00739"></a>00739         {
<a name="l00740"></a>00740             <span class="comment">//Liste für Texte aus Elementen, die dem Element other direkt untergeordnet sind.</span>
<a name="l00741"></a>00741             List&lt;String&gt; elemsPerOther = <span class="keyword">new</span> List&lt;String&gt;();
<a name="l00742"></a>00742 
<a name="l00743"></a>00743             <span class="comment">//Falls untergeordnete Elemente im Element other vorhanden sind, ...</span>
<a name="l00744"></a>00744             <span class="keywordflow">if</span> (other.HasElements)
<a name="l00745"></a>00745             {
<a name="l00746"></a>00746                 <span class="comment">// ... so durchlaufe sie ...</span>
<a name="l00747"></a>00747                 <span class="keywordflow">foreach</span> (XElement otherElem <span class="keywordflow">in</span> other.Elements())
<a name="l00748"></a>00748                 {
<a name="l00749"></a>00749                     <span class="comment">// ... und falls ein Klammerausdruck benötigt wird, ...</span>
<a name="l00750"></a>00750                     <span class="keywordflow">if</span> (otherElem.Name == xns + <span class="stringliteral">&quot;bracket&quot;</span>)
<a name="l00751"></a>00751                     {
<a name="l00752"></a>00752                         <span class="comment">// ... ermittle die Texte in der Klammer mit manage_bracketData.</span>
<a name="l00753"></a>00753                         <span class="keywordtype">string</span> bracketContent = manage_bracketData(otherElem);
<a name="l00754"></a>00754                         <span class="comment">//Falls etwas gefunden wurde, setze die Klammern entsprechend und sammle den String mit elemsPerOther auf.</span>
<a name="l00755"></a>00755                         <span class="keywordflow">if</span> (bracketContent != <span class="stringliteral">&quot;&quot;</span>) elemsPerOther.Add(<span class="stringliteral">&quot;(&quot;</span> + bracketContent + <span class="stringliteral">&quot;)&quot;</span>);
<a name="l00756"></a>00756                     }
<a name="l00757"></a>00757                     <span class="comment">//Ansonsten rufe manage_otherData für otherElem auf (Rekursivität). Wird Text zurückgegeben, so sammle in in der Liste elemsPerOther auf.</span>
<a name="l00758"></a>00758                     <span class="keywordflow">else</span>
<a name="l00759"></a>00759                     {
<a name="l00760"></a>00760                         <span class="keywordtype">string</span> otherElemContent = manage_otherData(otherElem);
<a name="l00761"></a>00761                         <span class="keywordflow">if</span> (otherElemContent != <span class="stringliteral">&quot;&quot;</span>) elemsPerOther.Add(otherElemContent);
<a name="l00762"></a>00762                     }
<a name="l00763"></a>00763                 }
<a name="l00764"></a>00764             }
<a name="l00765"></a>00765             <span class="comment">//Hier wird der Text des Elements other gesammelt, falls es keine untergeordneten Elemente besitzt und falls ein solcher Text vorhanden ist.</span>
<a name="l00766"></a>00766             <span class="keywordflow">else</span>
<a name="l00767"></a>00767             {
<a name="l00768"></a>00768                 <span class="keywordflow">if</span> (other.Value != <span class="stringliteral">&quot;&quot;</span>) elemsPerOther.Add(other.Value);
<a name="l00769"></a>00769             }
<a name="l00770"></a>00770             <span class="comment">//Kombiniere die Texte in elemsPerOther mit &quot;, &quot; und gib den so erhaltenen String zurück.</span>
<a name="l00771"></a>00771             <span class="keywordflow">return</span> String.Join(<span class="stringliteral">&quot;, &quot;</span>, elemsPerOther);
<a name="l00772"></a>00772         }
<a name="l00773"></a>00773 <span class="comment"></span>
<a name="l00774"></a>00774 <span class="comment">        /// @endcond </span>
<a name="l00775"></a>00775 <span class="comment"></span>    }
<a name="l00776"></a>00776 }
</pre></div></div><!-- contents -->
</div>
<!-- window showing the filter options -->
<div id="MSearchSelectWindow"
     onmouseover="return searchBox.OnSearchSelectShow()"
     onmouseout="return searchBox.OnSearchSelectHide()"
     onkeydown="return searchBox.OnSearchSelectKey(event)">
<a class="SelectItem" href="javascript:void(0)" onclick="searchBox.OnSelectItem(0)"><span class="SelectionMark">&#160;</span>Alle</a><a class="SelectItem" href="javascript:void(0)" onclick="searchBox.OnSelectItem(1)"><span class="SelectionMark">&#160;</span>Klassen</a><a class="SelectItem" href="javascript:void(0)" onclick="searchBox.OnSelectItem(2)"><span class="SelectionMark">&#160;</span>Namensbereiche</a><a class="SelectItem" href="javascript:void(0)" onclick="searchBox.OnSelectItem(3)"><span class="SelectionMark">&#160;</span>Funktionen</a><a class="SelectItem" href="javascript:void(0)" onclick="searchBox.OnSelectItem(4)"><span class="SelectionMark">&#160;</span>Variablen</a><a class="SelectItem" href="javascript:void(0)" onclick="searchBox.OnSelectItem(5)"><span class="SelectionMark">&#160;</span>Propertys</a></div>

<!-- iframe showing the search results (closed by default) -->
<div id="MSearchResultsWindow">
<iframe src="javascript:void(0)" frameborder="0" 
        name="MSearchResults" id="MSearchResults">
</iframe>
</div>

  <div id="nav-path" class="navpath">
    <ul>
      <li class="navelem"><b>SearchEngine.cs</b>      </li>

    <li class="footer">Erzeugt am Fre Mär 2 2012 15:52:52 für JaDe Tokenizer von
    <a href="http://www.doxygen.org/index.html">
    <img class="footer" src="doxygen.png" alt="doxygen"/></a> 1.7.6.1 </li>
   </ul>
 </div>


</body>
</html>
